Hi everyone I was reading about final in a Java book and how java.lang.String is a final class so it can't be extended and the book was explaining about how it would be dangerous and chaotic to have alternative implementations of String be accepted polymorphically by methods but Clojure's polymorphism allows you to extend even final classes, if so then wouldn't that be dangerous also or is there something I'm not understanding that makes this OK to do?

@flyingpython In Java, polymorphism is intrinsically tied to inheritance. In Clojure, that is not the case.

Clojure's polymorphism is, essentially, a la carte. Protocols allow you to associate type-based dispatch with additional functionality.

For example, in next.jdbc, it has the concepts of "sourceable" -- something you can make a datasource from -- and "connectable" -- something you can make a connection from. That allows you to treat a number of things in a consistent, polymorphic, manner and work in a natural way with things that perhaps weren't designed with the affordances you need.

Thanks for the explanations, yes the book I am working through on Clojure said working with databases is a common use case for Clojure's polymorphism

I know I ask this yesterday but the solution then do not seem to solve it

clj::ground_up.chapter5=> (ns ground-up.chapter5)
nil
clj::ground-up.chapter5=> 
; Syntax error compiling at (chapter5.clj:38:1).
; Unable to resolve symbol: defn in this context

code :

(defn palindrome?
  "Checks if a word is a palingdrome"
  [word]
  (= (seq word) (reverse word)))

In a cider repl, how do I print a “complex” map in a def-friendly way? I would like to be able to cut & paste from repl into a def in testing code, but I run into issues like lists being (1 2 3) in the output instead of ’(1 2 3) or (list 1 2 3), for example.

Do I have to do prn and use reader?

Can someone explain this :

(defn palindrome?
  "Checks if a word is a palingdrome"
  [word]
  (= (seq word) (reverse word)))

(defn countPalingdromes
  "count the number of palingdromes between 0 and 9999"
  []
  (->> (range 0 9999) (filter palindrome?) (count)))

; Execution error (IllegalArgumentException) at ground-up.chapter5/palindrome? (form-init12029216532296771069.clj:41).
; Don't know how to create ISeq from: java.lang.Long

Anyone know how to request with content-type image/png in reitit? I need to create upload image API. Multipart also won't works, i keep getting ClassNotFoundException javax.servlet.http.HttpServletRequest

how do I make it work that the message is printed

(def logging-enabled :true)

(defmacro log [message]
  (if (= logging-enabled :true)
    '(prn message)
    nil))

(macroexpand `(log :hi))

right now I see (prn message) as output

before I forget this is the challenge I try to solve:

; Write a macro log which uses a var, logging-enabled, to determine whether or 
; not to print an expression to the console at compile time. If logging-enabled 
; is false, (log :hi) should macroexpand to nil. If logging-enabled is true, 
; (log :hi) should macroexpand to (prn :hi) .

not funny

if I restart vs code I see this as soon as I do crtl - enter

Syntax error compiling at (chapter5.clj:62:1).
; Unable to resolve symbol: defmacro in this context

even if I do (ns ground_up.chapter5)

wierd, if i do crtl-enter first on a defn and then on the defmacro it works, If I do tit direct on a defmacro I see the above error

Hello Clojurians, I am trying to build subsequences from an original seq according to specific criteria (4Clojure p53, https://www.4clojure.com/problem/53#prob-title). I am trying to implement it via a recursive function, any suggestions for a higher level approach? Thanks in advance.

@mzuppichin a code walk through of how I put together first a very low abstraction loop recur and then used partition for a higher level of abstraction https://github.com/practicalli/four-clojure/blob/master/src/four_clojure/053_longest_increasing_sub_seq.clj

There is also a video of this walk through here https://www.youtube.com/watch?v=pyIbP4BOGpQ&list=PLpr9V-R8ZxiDjyU7cQYWOEFBDR1t7t0wv&index=36

@jr0cket Thanks sincerely, I have tons of material to study now!

Thanks for the quick and exhaustive response!

If you can find any other solutions, do let me know 🙂

any expert who can give feedback on my code : https://github.com/RoelofWobben/Learning_in_public/blob/main/ground_up/src/ground_up/chapter5.clj

Do any of you know if the spit function reads entire file content when using the append true parameter?

Confusing this :

user=> (def x (future (prn "hi") (+ 1 2)))
"hi"
#'user/x
user=> (deref x)
3

why does hi printed direct and the adding later

why not both later ?

is there a function build-in which reverses the args of a binary function. i.e. which maps f to (fn [a b] (f b a)) ?

of course I can write this but it is one of those functions like comp which is useful when doing functional manipulation

I need this most often when using condp to reverse the args of the predicate

I need to find the most frequent element of a sequence, and how many times it occurs. The way I'm doing it seems awkward.

(defn most-frequent [items]
  (reduce (fn [[td c] [td' c']]
            (if (< c' c)
              [td c] 
              [td' c']))
          [:empty-set 0]
          (frequencies items)))

(->> (frequencies [1 2 3 1 3]) (sort-by val >))
([1 2] [3 2] [2 1])

When I first checked out the frequencies source, I learned like 3 new things at once. And the function is only a couple of lines long

It’s very motivating to read the clojure.core sources for these utility functions.

I think the documentation for condp is wrong. can someone help me read it and figure out if I'm confused. The documentation says that the expression (pred test-expr expr) is evaluated repeatedly, however it appears to me that expr is only evaluated once, into a tmp-var and the expression that is evaluated repeatedly is (pred-test-expr tmp-var)

This is of course the desired behavior, but not the documented behavior.

I think that's what that doc is trying to convey

I agree that that is what's intended, and it is what the user would assume from NOT reading the doc. But when I read it carefully, I had to perform an experiment to verify.

if you're using a side effecting expr where you would see a different result between those two interpretations, then I would suggest maybe that's a bad idea

Hello all, I'm trying to create a CSV using (https://clojure.github.io/data.csv/) , however I don't want to write to disk and would like the output to be a byte array. Because I'm unfamiliar with writer, I'm not sure how to do this. (with-open [writer (io/writer file-path)] (clojure.data.csv/write-csv data file-path)) How can I change this to return a byte array and not write to disk? Thanks

I am working on rewrite-cljc docs and want to check my terminology usage. When I first came to Clojure I really had no concept “form” or “sexpr”. Maybe I still need help. Can these terms be used interchangeably? Is the difference https://clojure.org/guides/learn/syntax#_structure_vs_semantics?

I know that a string in quotes is an expression, but I'm not sure whether a non-parenthesized piece of text is a form????

strings and numbers and symbols are s-expressions.

are they forms?

Confusing this :

user=> (def x (future (prn "hi") (+ 1 2)))
"hi"
#'user/x
user=> (deref x)
3

future runs the expression in a different thread

concurrent to the main repl thread

(although they both share the same stdout which can be confusing)

from (doc future) > Takes a body of expressions and yields a future object that will > invoke the body in another thread, and will cache the result and > return it on all subsequent calls to deref/@.

so "hi" is being printed in thread 2, then the deref returns the result of the expression and prints it in the main thread

oke, so printed cannot be deferred. If I would do there another calculation then both were deffered ?

it sounds like you are expecting the behavior of delay

a delayed expression is only run once you deref or force the delay (and happens on the same thread)

I expect nothing but try to understand what happens. It thought both are deffered but I see the output of `(prn "hi") direct and I try to understand why that one is direct executed and the calculation is deffered

there is no real ordering of output from another thread (the future) and the output from the repl process (prompting you for input)

they both just print whenever they want, they are independent threads

so basically it is a race condition, how the output of the repl is interleaved with the output of the future

future will evaluate everything in its body as soon as possible, in a separate thread, subject to operating system, thread scheduling, etc. constraints.

so "hi" may print out first, or after #'user/x, or after you deref

^^ future is not about future evaluation, it's about getting the result in the future

evaluation is immediate and concurrent

Clojure Applied has a great chapter on all this btw, also the author is quite strong and handsome

@roelof perhaps one source of your confusion is that some output in the repl is the implicit print of values as you ask for them to be calcuated, and other output is arbitrary printing behavior?

oke, so using a future is not a good thing because you never know when the result is returned. And there im confused

the result is returned when you ask for it

any random prints are done as they are executed

this is why I was pointing out the distinction between things implicitly printed (because your REPL form returned them), and things explicitly printed (because you wrote code that prints)

the result of an expression, and output printed by an expression are not the same thing

> oke, so using a future  is not a good thing a future is a thing that could be exactly what you need or very inappropriate. Can you explain what you want to accomplish and the advice can be more tailored to that?

oke, lets say we have this : (def x (future (* 3 4 ) (+ 1 2))) I see a message #'ground-up.chapter5/x which is the 3

but where is the outcome of ( *3 4) ?

(do (+ 1 2) (+ 10 20)) will return 30. the (+ 1 2) is computed and ignored as its unused anywhere and not returned

oke

this isn't just a property of future (which contains an implicit do), it also applies to other places that contain a do block, like let, fn, defmacro, doseq, loop...

all forms in the do block but the one you return are only useful as side effects

oke, I think I understand it but still I think a wierd example in the book to explain futures

it's showing that the execution happens immediately (via the print side effect), and you can get the value whenever you are ready for it

it seems like it really demonstrated what's going on. the println happened immediately and the value comes when derefed. Pretty good probing of how future runs immediately and caches its value for dereferencing

anyone more who want ot give feedback on my code.See question on the code-review chapter

Hi, I have this deps.edn

{:paths ["src" "resources"]
 :deps {org.clojure/clojure {:mvn/version "1.10.1"}
        aysylu/loom {:mvn/version "1.0.2"}
        org.clojure/math.combinatorics {:mvn/version "0.1.6"}}
 :aliases
 {:remote-repl {:extra-deps {vlaaad/remote-repl {:mvn/version "1.1"}}}
  :reveal {:extra-deps {vlaaad/reveal {:mvn/version "1.0.130"}}}
  :test {:extra-paths ["test"]
         :extra-deps {org.clojure/test.check {:mvn/version "1.0.0"}}}
  :runner
  {:extra-deps {com.cognitect/test-runner
                {:git/url ""
                 :sha "b6b3193fcc42659d7e46ecd1884a228993441182"}}
   :main-opts ["-m" "cognitect.test-runner"
               "-d" "test"]}
  :uberjar {:extra-deps {seancorfield/depstar {:mvn/version "1.1.128"}}
            :main-opts ["-m" "hf.depstar.uberjar" "aoc.jar"
                        "-C" "-m" "stuartstein777.aoc"]}}}

(ns stuartstein777.2020.day10
  (:require [clojure.string :as str]
            [clojure.math.combinatorics :as combo]))

Execution error (FileNotFoundException) at stuartstein777.2020.day10/eval1477$loading (day10.clj:1).
Could not locate clojure/math/combinatorics__init.class, clojure/math/combinatorics.clj or clojure/math/combinatorics.cljc on classpath.

Cant run REVL either, and this also worked until yesterday. Now it says cant run REVL, no project file found.

Maybe I just need to recreate the project from scratch with clj-new ?

it sounds like something in IntelliJ that needs fixing, not clj

yeah, i just tried another project that 100% worked, and woudl run REVL too. Now it doesn't work either.

Man, I have no other editor setup to do clojure

Guess I can use my other machine that doesn't have latest IntelliJ

running clj in a terminal, then using require to load your namespace should still work (or at least get further than not seeing a dep that's in your config)

You might want to post something in the #cursive channel

Hi Everyone, I am a Javascript developer, I recently gotten introduced to Clojure world by a React ClojureScript application. Are there any good resources you would recommend that would will help me with this transition?

@singhamritpal49 If you're using Reagent, this might be a nice one: https://www.learnreagent.com/

@singhamritpal49 There's also lots of resources listed here: https://gist.github.com/yogthos/be323be0361c589570a6da4ccc85f58f

Hmm.. the free version of that course never loads for me.. I just get loads of errors in the js console

In chromium it works fine, the errors were just for firefox

Maybe pass that as feedback to the author. It's kind of ironic that a webdev course doesn't work in all browsers.

yes, that's the same thing I thought 😂 I already wrote about this problem in the chat that popped up

Hi! This is a good challenge for Clojure: https://twitter.com/wesbos/status/1337453660482187268 I'm sure there are a clean and simple way to solved this. What functions do you think are appropriate in order to achieve the results?

A library was used, but I like the R version 👍 https://twitter.com/matthewpaulking/status/1337461670243799040

I have looked into the question and I am thinking of using merge-with, reduce, etc.

(let [col [["name" "id" "height"] ["Bob" "2" "50"] ["John" "1" "45"]]]
  (map #(zipmap (map keyword (first col)) %) (rest col)))
({:name "Bob", :id "2", :height "50"}
 {:name "John", :id "1", :height "45"})

I’m doing well with “simple” recursion, like with loop/recur or without. But what I am struggling with is the case when I have to recur into a list of things … like when generating a tree or explore multiple paths

I have gotten into the habit of starting with something like an secd or cek machine whenever I need to process a tree, because those are abstract machines for evaluating programs, and programs are trees

the idea of storing continuations in a stack, processing a list of results and then doing something in the middle of a tree, etc are common features of tree processing and program evaluation

I can't claim it is good, I don't think the programs that come out of it are particularly readable

interesting i should look into that ..

but it seems to be a universal technique

the last thing I did that with is a pretty printer for graphql schemas and it is very ugly

i need to read about some basic algorithms about path exploring i think

another thing you might look at is zippers

advent of code related 🙂

clojure ships with clojure.zip, which doesn't get a lot of love

there is also clojure.walk

oh zipper may actually be what i want

related to zippers are lenses, which there are a few clojure libraries for, or something like spectre

i think i basically need something higher level that allows me to give it a function to answer ‘what are the children for this node’ repeatedly until i have no more data for that branch

looks like a zipper may be able to do this

if you need to edit nodes in a nested immutable data structure, zippers are awesome. for simply walking a nested data structure, tree-seq can be an easier alternative

i need to generate it first 🙂

and then count stuff in it