How to Create Clojure `defn` Functions automatically?
A recent question on StackOverflow raised the question of the best way to
automatically generate functions. Suppose you want to automate the creation
of code like this:
(def foo
{:able"Adelicious!"
:baker "Barbrallicious!"
:charlie "Charlizable"})
(def bar
{:able"Apple"
:baker "Berry"
:charlie "Kumquat"})
(defn manual-my-foo [item] (get foo item))
(defn manual-my-bar [item] (get bar item))
(manual-my-foo :able) => "Adelicious!"
(manual-my-bar :charlie) => "Kumquat"
You could write a macro to generate one of these at a time, but you can't
pass a macro to a higher-order function like `map`, so while this would
work:
(generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
this wouldn't work:
(map generate-fn [:foo :bar :baz])
While one could write a 2nd macro to replace `map`, this is a symptom of
the "Turtles All the Way Down" problem. One workaround is to avoid macros
altogether and use only functions to generate the required `my-foo` and
`my-bar` functions. The trick is to make use of the built-in Clojure
function `intern` both to save the newly generated functions into the
global environment and to retrieve the pre-existing maps `foo` and `bar`.
Full details are available Q&A-style at the StackOverflow post
.
Enjoy,
Alan
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Workshop on Functional Art, Music, Modelling and Design (Sep 9, Oxford): Call for Papers and Performances
Clojure submissions are very welcome at the FARM! 5th ACM SIGPLAN International Workshop on Functional Art, Music, Modelling and Design Oxford, UK, September, 9th 2017 Call for Papers and Performances Key Dates: Paper submission deadline June 1, 2017 Performance submission deadline June 18, 2017 Author NotificationJuly 1, 2017 Camera Ready July 13, 2017 Call for Papers and Demos: The ACM SIGPLAN International Workshop on Functional Art, Music, Modelling and Design (FARM) gathers together people who are harnessing functional techniques in the pursuit of creativity and expression. It is co-located with ICFP 2017, the 22nd ACM SIGPLAN International Conference on Functional Programming. Functional Programming has emerged as a mainstream software development paradigm, and its artistic and creative use is booming. A growing number of software toolkits, frameworks and environments for art, music and design now employ functional programming languages and techniques. FARM is a forum for exploration and critical evaluation of these developments, for example to consider potential benefits of greater consistency, tersity, and closer mapping to a problem domain. FARM encourages submissions from across art, craft and design, including textiles, visual art, music, 3D sculpture, animation, GUIs, video games, 3D printing and architectural models, choreography, poetry, and even VLSI layouts, GPU configurations, or mechanical engineering designs. Theoretical foundations, language design, implementation issues, and applications in industry or the arts are all within the scope of the workshop. The language used need not be purely functional (“mostly functional” is fine), and may be manifested as a domain specific language or tool. Moreover, submissions focusing on questions or issues about the use of functional programming are within the scope. Call for Performances: FARM also hosts a traditional evening of performances. For this year’s event, FARM 2017 is seeking proposals for live performances which employ functional programming techniques, in whole or in part. We would like to support a diverse range of performing arts, including music, dance, video animation, and performance art. We encourage both risk-taking proposals which push forward the state of the art and refined presentations of highly-developed practice. In either case, please support your submission with a clear description of your performance including how your performance employs functional programming and a discussion of influences and prior art as appropriate. FARM 2017 website : http://functional-art.org/2017/ Submissions We welcome submissions from academic, professional, and independent programmers and artists. Submissions are invited in three categories: 1) Original papers We solicit original papers in the following categories: - Original research - Overview / state of the art - Technology tutorial All submissions must propose an original contribution to the FARM theme. FARM is an interdisciplinary conference, so a wide range of approaches are encouraged. An original paper should have 5 to 12 pages, be in portable document format (PDF), using the ACM SIGPLAN style guidelines and use the ACM SIGPLAN template. [ http://www.sigplan.org/Resources/Author/ ] Accepted papers will be published in the ACM Digital Library as part of the FARM 2017 proceedings. See http://authors.acm.org/main.cfm for information on the options available to authors. Authors are encouraged to submit auxiliary material for publication along with their paper (source code, data, videos, images, etc.); authors retain all rights to the auxiliary material. 2) Demo proposals Demo proposals should describe a demonstration to be given at the FARM workshop and its context, connecting it with the themes of FARM. A demo could be in the form of a short (10-20 minute) tutorial, presentation of work-in-progress, an exhibition of some work, or even a performance. Demo proposals should be in plain text, HTML or Markdown format, and not exceed 2000 words. A demo proposal should be clearly marked as such, by prepending Demo Proposal: to the title. Demo proposals will be published on the FARM website. A summary of the demo performances will also be published as part of the conference proceedings, to be prepared by the program chair. 3) Calls for collaboration Calls for collaboration should describe a need for technology or expertise related to the FARM theme. Examples may include but are not restricted to: - art projects in need of realization - existing software or hardware that may benefit from functional programming - unfinished projects in need of inspiration Calls for collaboration should be in plain text, HTML or Markdown format, and not exceed 5000 words. A call for collaboration should be clearly marked as such, by prepending Call for Collaboration: to the title. Calls for collaboration will be
Re: How to Create Clojure `defn` Functions automatically?
What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
"Adelicious!"?
On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>
> A recent question on StackOverflow raised the question of the best way to
> automatically generate functions. Suppose you want to automate the creation
> of code like this:
>
>
>
> (def foo
> {:able"Adelicious!"
>:baker "Barbrallicious!"
>:charlie "Charlizable"})
> (def bar
> {:able"Apple"
>:baker "Berry"
>:charlie "Kumquat"})
>
> (defn manual-my-foo [item] (get foo item))
> (defn manual-my-bar [item] (get bar item))
>
> (manual-my-foo :able) => "Adelicious!"
> (manual-my-bar :charlie) => "Kumquat"
>
>
> You could write a macro to generate one of these at a time, but you can't
> pass a macro to a higher-order function like `map`, so while this would
> work:
>
>
> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>
>
> this wouldn't work:
>
>
> (map generate-fn [:foo :bar :baz])
>
> While one could write a 2nd macro to replace `map`, this is a symptom of
> the "Turtles All the Way Down" problem. One workaround is to avoid macros
> altogether and use only functions to generate the required `my-foo` and
> `my-bar` functions. The trick is to make use of the built-in Clojure
> function `intern` both to save the newly generated functions into the
> global environment and to retrieve the pre-existing maps `foo` and `bar`.
> Full details are available Q&A-style at the StackOverflow post
>
> .
>
> Enjoy,
> Alan
>
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
[ANN] irresponsible/anarchy (business logic engine driven by tabular data) v0.2.0
The Irresponsible Clojure Guild is pleased to announce a new version of the 'anarchy' business logic engine. This version features better resistance against nil-returning predicates and completely rewritten documentation that is hopefully significantly easier to understand. The docs are still a work in progress. Please file issues if you have difficulty understanding anything. dep coord: [irresponsible/anarchy "0.2.0"] github: https://github.com/irresponsible/anarchy Cheers, James (and the rest of the guild) -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en --- You received this message because you are subscribed to the Google Groups "Clojure" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojure+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
Re: How to Create Clojure `defn` Functions automatically?
This is a somewhat weird answer to a overcomplicated problem. As mentioned,
the data is a map to start with, and maps are functions so treating the
maps as data is probably the best approach. And like Dragan, I'm unsure why
this example doesn't use `(data :able)`.
When I do need to generate functions at runtime, and I can't use macros
(for the reasons mentioned), I'll either use a macro that creates a var, or
use eval perhaps in conjunction with a memoize. I used this a lot in my
work with JavaFx. Do some reflection, generate some code, eval the code and
return a function, memoize that process so we can get the generated
function via name. So the interface looks like this:
((get-setter button :text) "hey")
Get-setter does a ton of reflection, but calling the returned function
remains fast due to the combination of eval and memoization.
On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric wrote:
> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
> "Adelicious!"?
>
>
> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>>
>> A recent question on StackOverflow raised the question of the best way to
>> automatically generate functions. Suppose you want to automate the creation
>> of code like this:
>>
>>
>>
>> (def foo
>> {:able"Adelicious!"
>>:baker "Barbrallicious!"
>>:charlie "Charlizable"})
>> (def bar
>> {:able"Apple"
>>:baker "Berry"
>>:charlie "Kumquat"})
>>
>> (defn manual-my-foo [item] (get foo item))
>> (defn manual-my-bar [item] (get bar item))
>>
>> (manual-my-foo :able) => "Adelicious!"
>> (manual-my-bar :charlie) => "Kumquat"
>>
>>
>> You could write a macro to generate one of these at a time, but you can't
>> pass a macro to a higher-order function like `map`, so while this would
>> work:
>>
>>
>> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>>
>>
>> this wouldn't work:
>>
>>
>> (map generate-fn [:foo :bar :baz])
>>
>> While one could write a 2nd macro to replace `map`, this is a symptom of
>> the "Turtles All the Way Down" problem. One workaround is to avoid macros
>> altogether and use only functions to generate the required `my-foo` and
>> `my-bar` functions. The trick is to make use of the built-in Clojure
>> function `intern` both to save the newly generated functions into the
>> global environment and to retrieve the pre-existing maps `foo` and `bar`.
>> Full details are available Q&A-style at the StackOverflow post
>>
>> .
>>
>> Enjoy,
>> Alan
>>
>> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
--
“One of the main causes of the fall of the Roman Empire was that–lacking
zero–they had no way to indicate successful termination of their C
programs.”
(Robert Firth)
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
[Job] Software Engineer at Puppet
My team, which works on https://github.com/puppetlabs/puppetdb, is hiring a software engineer. We mostly use Clojure. https://puppet.com/company/careers/jobs?gh_jid=685071 (The page says Portland, but we're gladly open to anyone in US time zones) - Russell -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en --- You received this message because you are subscribed to the Google Groups "Clojure" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojure+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
Re: How to Create Clojure `defn` Functions automatically?
That's why I avoided to answer the main question. In my experience,
whenever I thought I needed some weirdly complicated stuff like the one in
the example, there existed much simpler solution that used regular
techniques. So, when I encounter similar problems the first thing I do is
to try to redefine the problem to avoid such hazardous coding practices. I
do not claim that it is always possible, but I could bet it is possible in
*most* cases, especially those where it is difficult to think up a demo of
the problem.
On Thursday, May 11, 2017 at 4:58:48 PM UTC+2, tbc++ wrote:
>
> This is a somewhat weird answer to a overcomplicated problem. As
> mentioned, the data is a map to start with, and maps are functions so
> treating the maps as data is probably the best approach. And like Dragan,
> I'm unsure why this example doesn't use `(data :able)`.
>
> When I do need to generate functions at runtime, and I can't use macros
> (for the reasons mentioned), I'll either use a macro that creates a var, or
> use eval perhaps in conjunction with a memoize. I used this a lot in my
> work with JavaFx. Do some reflection, generate some code, eval the code and
> return a function, memoize that process so we can get the generated
> function via name. So the interface looks like this:
>
> ((get-setter button :text) "hey")
>
> Get-setter does a ton of reflection, but calling the returned function
> remains fast due to the combination of eval and memoization.
>
>
>
> On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric > wrote:
>
>> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
>> "Adelicious!"?
>>
>>
>> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>>>
>>> A recent question on StackOverflow raised the question of the best way
>>> to automatically generate functions. Suppose you want to automate the
>>> creation of code like this:
>>>
>>>
>>>
>>> (def foo
>>> {:able"Adelicious!"
>>>:baker "Barbrallicious!"
>>>:charlie "Charlizable"})
>>> (def bar
>>> {:able"Apple"
>>>:baker "Berry"
>>>:charlie "Kumquat"})
>>>
>>> (defn manual-my-foo [item] (get foo item))
>>> (defn manual-my-bar [item] (get bar item))
>>>
>>> (manual-my-foo :able) => "Adelicious!"
>>> (manual-my-bar :charlie) => "Kumquat"
>>>
>>>
>>> You could write a macro to generate one of these at a time, but you
>>> can't pass a macro to a higher-order function like `map`, so while this
>>> would work:
>>>
>>>
>>> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>>>
>>>
>>> this wouldn't work:
>>>
>>>
>>> (map generate-fn [:foo :bar :baz])
>>>
>>> While one could write a 2nd macro to replace `map`, this is a symptom of
>>> the "Turtles All the Way Down" problem. One workaround is to avoid macros
>>> altogether and use only functions to generate the required `my-foo` and
>>> `my-bar` functions. The trick is to make use of the built-in Clojure
>>> function `intern` both to save the newly generated functions into the
>>> global environment and to retrieve the pre-existing maps `foo` and `bar`.
>>> Full details are available Q&A-style at the StackOverflow post
>>>
>>> .
>>>
>>> Enjoy,
>>> Alan
>>>
>>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clo...@googlegroups.com
>>
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+u...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> ---
>> You received this message because you are subscribed to the Google Groups
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to clojure+u...@googlegroups.com .
>> For more options, visit https://groups.google.com/d/optout.
>>
>
>
>
> --
> “One of the main causes of the fall of the Roman Empire was that–lacking
> zero–they had no way to indicate successful termination of their C
> programs.”
> (Robert Firth)
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Re: How to Create Clojure `defn` Functions automatically?
The original question (
http://stackoverflow.com/questions/43897632/mapped-calls-to-clojurescript-macro)
was about automatically generating callback functions for CLJS. Perhaps I
oversimplified it too much for the example.
Alan
On Thu, May 11, 2017 at 1:55 AM, Dragan Djuric wrote:
> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
> "Adelicious!"?
>
>
> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>>
>> A recent question on StackOverflow raised the question of the best way to
>> automatically generate functions. Suppose you want to automate the creation
>> of code like this:
>>
>>
>>
>> (def foo
>> {:able"Adelicious!"
>>:baker "Barbrallicious!"
>>:charlie "Charlizable"})
>> (def bar
>> {:able"Apple"
>>:baker "Berry"
>>:charlie "Kumquat"})
>>
>> (defn manual-my-foo [item] (get foo item))
>> (defn manual-my-bar [item] (get bar item))
>>
>> (manual-my-foo :able) => "Adelicious!"
>> (manual-my-bar :charlie) => "Kumquat"
>>
>>
>> You could write a macro to generate one of these at a time, but you can't
>> pass a macro to a higher-order function like `map`, so while this would
>> work:
>>
>>
>> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>>
>>
>> this wouldn't work:
>>
>>
>> (map generate-fn [:foo :bar :baz])
>>
>> While one could write a 2nd macro to replace `map`, this is a symptom of
>> the "Turtles All the Way Down" problem. One workaround is to avoid macros
>> altogether and use only functions to generate the required `my-foo` and
>> `my-bar` functions. The trick is to make use of the built-in Clojure
>> function `intern` both to save the newly generated functions into the
>> global environment and to retrieve the pre-existing maps `foo` and `bar`.
>> Full details are available Q&A-style at the StackOverflow post
>>
>> .
>>
>> Enjoy,
>> Alan
>>
>> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Re: How to Create Clojure `defn` Functions automatically?
I like the idea of using `eval` and `memoize`. I'll have to keep that in
mind.
Alan
On Thu, May 11, 2017 at 7:58 AM, Timothy Baldridge
wrote:
> This is a somewhat weird answer to a overcomplicated problem. As
> mentioned, the data is a map to start with, and maps are functions so
> treating the maps as data is probably the best approach. And like Dragan,
> I'm unsure why this example doesn't use `(data :able)`.
>
> When I do need to generate functions at runtime, and I can't use macros
> (for the reasons mentioned), I'll either use a macro that creates a var, or
> use eval perhaps in conjunction with a memoize. I used this a lot in my
> work with JavaFx. Do some reflection, generate some code, eval the code and
> return a function, memoize that process so we can get the generated
> function via name. So the interface looks like this:
>
> ((get-setter button :text) "hey")
>
> Get-setter does a ton of reflection, but calling the returned function
> remains fast due to the combination of eval and memoization.
>
>
>
> On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric wrote:
>
>> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
>> "Adelicious!"?
>>
>>
>> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>>>
>>> A recent question on StackOverflow raised the question of the best way
>>> to automatically generate functions. Suppose you want to automate the
>>> creation of code like this:
>>>
>>>
>>>
>>> (def foo
>>> {:able"Adelicious!"
>>>:baker "Barbrallicious!"
>>>:charlie "Charlizable"})
>>> (def bar
>>> {:able"Apple"
>>>:baker "Berry"
>>>:charlie "Kumquat"})
>>>
>>> (defn manual-my-foo [item] (get foo item))
>>> (defn manual-my-bar [item] (get bar item))
>>>
>>> (manual-my-foo :able) => "Adelicious!"
>>> (manual-my-bar :charlie) => "Kumquat"
>>>
>>>
>>> You could write a macro to generate one of these at a time, but you
>>> can't pass a macro to a higher-order function like `map`, so while this
>>> would work:
>>>
>>>
>>> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>>>
>>>
>>> this wouldn't work:
>>>
>>>
>>> (map generate-fn [:foo :bar :baz])
>>>
>>> While one could write a 2nd macro to replace `map`, this is a symptom of
>>> the "Turtles All the Way Down" problem. One workaround is to avoid macros
>>> altogether and use only functions to generate the required `my-foo` and
>>> `my-bar` functions. The trick is to make use of the built-in Clojure
>>> function `intern` both to save the newly generated functions into the
>>> global environment and to retrieve the pre-existing maps `foo` and `bar`.
>>> Full details are available Q&A-style at the StackOverflow post
>>>
>>> .
>>>
>>> Enjoy,
>>> Alan
>>>
>>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clojure@googlegroups.com
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+unsubscr...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> ---
>> You received this message because you are subscribed to the Google Groups
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to clojure+unsubscr...@googlegroups.com.
>> For more options, visit https://groups.google.com/d/optout.
>>
>
>
>
> --
> “One of the main causes of the fall of the Roman Empire was that–lacking
> zero–they had no way to indicate successful termination of their C
> programs.”
> (Robert Firth)
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" grou
Re: How to Create Clojure `defn` Functions automatically?
Since the original question was in CLJS, which has neither `intern` nor
`eval`, does that mean the macro mapping another macro approach is the only
solution there?
On Thu, May 11, 2017 at 9:18 AM, Alan Thompson wrote:
> I like the idea of using `eval` and `memoize`. I'll have to keep that in
> mind.
> Alan
>
> On Thu, May 11, 2017 at 7:58 AM, Timothy Baldridge
> wrote:
>
>> This is a somewhat weird answer to a overcomplicated problem. As
>> mentioned, the data is a map to start with, and maps are functions so
>> treating the maps as data is probably the best approach. And like Dragan,
>> I'm unsure why this example doesn't use `(data :able)`.
>>
>> When I do need to generate functions at runtime, and I can't use macros
>> (for the reasons mentioned), I'll either use a macro that creates a var, or
>> use eval perhaps in conjunction with a memoize. I used this a lot in my
>> work with JavaFx. Do some reflection, generate some code, eval the code and
>> return a function, memoize that process so we can get the generated
>> function via name. So the interface looks like this:
>>
>> ((get-setter button :text) "hey")
>>
>> Get-setter does a ton of reflection, but calling the returned function
>> remains fast due to the combination of eval and memoization.
>>
>>
>>
>> On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric
>> wrote:
>>
>>> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
>>> "Adelicious!"?
>>>
>>>
>>> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
A recent question on StackOverflow raised the question of the best way
to automatically generate functions. Suppose you want to automate the
creation of code like this:
(def foo
{:able"Adelicious!"
:baker "Barbrallicious!"
:charlie "Charlizable"})
(def bar
{:able"Apple"
:baker "Berry"
:charlie "Kumquat"})
(defn manual-my-foo [item] (get foo item))
(defn manual-my-bar [item] (get bar item))
(manual-my-foo :able) => "Adelicious!"
(manual-my-bar :charlie) => "Kumquat"
You could write a macro to generate one of these at a time, but you
can't pass a macro to a higher-order function like `map`, so while this
would work:
(generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
this wouldn't work:
(map generate-fn [:foo :bar :baz])
While one could write a 2nd macro to replace `map`, this is a symptom
of the "Turtles All the Way Down" problem. One workaround is to avoid
macros altogether and use only functions to generate the required `my-foo`
and `my-bar` functions. The trick is to make use of the built-in Clojure
function `intern` both to save the newly generated functions into the
global environment and to retrieve the pre-existing maps `foo` and `bar`.
Full details are available Q&A-style at the StackOverflow post
.
Enjoy,
Alan
--
>>> You received this message because you are subscribed to the Google
>>> Groups "Clojure" group.
>>> To post to this group, send email to clojure@googlegroups.com
>>> Note that posts from new members are moderated - please be patient with
>>> your first post.
>>> To unsubscribe from this group, send email to
>>> clojure+unsubscr...@googlegroups.com
>>> For more options, visit this group at
>>> http://groups.google.com/group/clojure?hl=en
>>> ---
>>> You received this message because you are subscribed to the Google
>>> Groups "Clojure" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to clojure+unsubscr...@googlegroups.com.
>>> For more options, visit https://groups.google.com/d/optout.
>>>
>>
>>
>>
>> --
>> “One of the main causes of the fall of the Roman Empire was that–lacking
>> zero–they had no way to indicate successful termination of their C
>> programs.”
>> (Robert Firth)
>>
>> --
>> You received this message because you are subscribed to the Google
>> Groups "Clojure" group.
>> To post to this group, send email to clojure@googlegroups.com
>> Note that posts from new members are moderated - please be patient with
>> your first post.
>> To unsubscribe from this group, send email to
>> clojure+unsubscr...@googlegroups.com
>> For more options, visit this group at
>> http://groups.google.com/group/clojure?hl=en
>> ---
>> You received this message because you are subscribed to the Google Groups
>> "Clojure" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to clojure+unsubscr...@googlegroups.com.
>> For more options, visit https://groups.google.com/d/optout.
>>
>
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegr
Re: How to Create Clojure `defn` Functions automatically?
I assume this is a real problem you are encountering since you wrote the
original Stack Overflow questions. As Dragan mentioned, this example
doesn't warrant such a complex solution, maps and keywords *are* function,
so all you really need is `foo` as a getter. Or even if they weren't
functions you still have `(partial get foo)`.
On Thu, May 11, 2017 at 10:27 AM, Alan Thompson wrote:
> Since the original question was in CLJS, which has neither `intern` nor
> `eval`, does that mean the macro mapping another macro approach is the only
> solution there?
>
>
> On Thu, May 11, 2017 at 9:18 AM, Alan Thompson wrote:
>
>> I like the idea of using `eval` and `memoize`. I'll have to keep that
>> in mind.
>> Alan
>>
>> On Thu, May 11, 2017 at 7:58 AM, Timothy Baldridge
>> wrote:
>>
>>> This is a somewhat weird answer to a overcomplicated problem. As
>>> mentioned, the data is a map to start with, and maps are functions so
>>> treating the maps as data is probably the best approach. And like Dragan,
>>> I'm unsure why this example doesn't use `(data :able)`.
>>>
>>> When I do need to generate functions at runtime, and I can't use macros
>>> (for the reasons mentioned), I'll either use a macro that creates a var, or
>>> use eval perhaps in conjunction with a memoize. I used this a lot in my
>>> work with JavaFx. Do some reflection, generate some code, eval the code and
>>> return a function, memoize that process so we can get the generated
>>> function via name. So the interface looks like this:
>>>
>>> ((get-setter button :text) "hey")
>>>
>>> Get-setter does a ton of reflection, but calling the returned function
>>> remains fast due to the combination of eval and memoization.
>>>
>>>
>>>
>>> On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric
>>> wrote:
>>>
What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
"Adelicious!"?
On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>
> A recent question on StackOverflow raised the question of the best way
> to automatically generate functions. Suppose you want to automate the
> creation of code like this:
>
>
>
> (def foo
> {:able"Adelicious!"
>:baker "Barbrallicious!"
>:charlie "Charlizable"})
> (def bar
> {:able"Apple"
>:baker "Berry"
>:charlie "Kumquat"})
>
> (defn manual-my-foo [item] (get foo item))
> (defn manual-my-bar [item] (get bar item))
>
> (manual-my-foo :able) => "Adelicious!"
> (manual-my-bar :charlie) => "Kumquat"
>
>
> You could write a macro to generate one of these at a time, but you
> can't pass a macro to a higher-order function like `map`, so while this
> would work:
>
>
> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>
>
> this wouldn't work:
>
>
> (map generate-fn [:foo :bar :baz])
>
> While one could write a 2nd macro to replace `map`, this is a symptom
> of the "Turtles All the Way Down" problem. One workaround is to avoid
> macros altogether and use only functions to generate the required `my-foo`
> and `my-bar` functions. The trick is to make use of the built-in Clojure
> function `intern` both to save the newly generated functions into the
> global environment and to retrieve the pre-existing maps `foo` and `bar`.
> Full details are available Q&A-style at the StackOverflow post
>
> .
>
> Enjoy,
> Alan
>
> --
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with
your first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send
an email to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
>>>
>>>
>>>
>>> --
>>> “One of the main causes of the fall of the Roman Empire was that–lacking
>>> zero–they had no way to indicate successful termination of their C
>>> programs.”
>>> (Robert Firth)
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "Clojure" group.
>>> To post to this group, send email to clojure@googlegroups.com
>>> Note that posts from new members are moderated - please be patient with
>>> your first post.
>>> To unsubscribe from this group, send email to
>>> clojure+unsubscr...@googlegroups.com
>>> For more options,
def with function call - how often executed?
If I write a def with a function call, such as:
(def x (+ 1 2))
and I use x a gazillion times in my code, does Clojure execute the function
("+" in this case) on each use?
Clearly, with (+ 1 2) it doesn't really matter, but if it is an expensive
function such as reading a file it is a big deal.
Tnx
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Re: How to Create Clojure `defn` Functions automatically?
Actually someone else wrote the original CLJS question (1):
http://stackoverflow.com/questions/43897632/mapped-calls-to-clojurescript-macro
It was marked as a duplicate of this question (2):
http://stackoverflow.com/questions/43897632/mapped-calls-to-clojurescript-macro
This one also had an answer using `intern` to avoid the need for a macro.
I didn't think question (1) was an exact duplicate of (2), and I wanted to
work out the details of solving (1) using `intern` instead of macros (it
seemed like a good goal at the time...). I tried to simplify question (1)
w/o the CLJS callback stuff, and may have oversimplified.
Since question was closed as being a "duplicate" (in error, I think), I
couldn't answer there and posed the Q&A style answer separately at (3):
http://stackoverflow.com/questions/43904628/how-to-create-clojure-defn-functions-automatically
The main goal I had here was simply finding a good way to avoid macros when
auto-generating functions, and to generalize/document the technique
described in (2) using `intern`.
Alan
P.S. Regarding (3), Joel Spolsky, creator of StackOverflow, has often
encouraged people to post both a question and its answer on the site:
https://stackoverflow.blog/2011/07/01/its-ok-to-ask-and-answer-your-own-questions
In fact, they even have a special button for this purpose.
On Thu, May 11, 2017 at 9:39 AM, Timothy Baldridge
wrote:
> I assume this is a real problem you are encountering since you wrote the
> original Stack Overflow questions. As Dragan mentioned, this example
> doesn't warrant such a complex solution, maps and keywords *are* function,
> so all you really need is `foo` as a getter. Or even if they weren't
> functions you still have `(partial get foo)`.
>
> On Thu, May 11, 2017 at 10:27 AM, Alan Thompson
> wrote:
>
>> Since the original question was in CLJS, which has neither `intern` nor
>> `eval`, does that mean the macro mapping another macro approach is the only
>> solution there?
>>
>>
>> On Thu, May 11, 2017 at 9:18 AM, Alan Thompson
>> wrote:
>>
>>> I like the idea of using `eval` and `memoize`. I'll have to keep that
>>> in mind.
>>> Alan
>>>
>>> On Thu, May 11, 2017 at 7:58 AM, Timothy Baldridge >> > wrote:
>>>
This is a somewhat weird answer to a overcomplicated problem. As
mentioned, the data is a map to start with, and maps are functions so
treating the maps as data is probably the best approach. And like Dragan,
I'm unsure why this example doesn't use `(data :able)`.
When I do need to generate functions at runtime, and I can't use macros
(for the reasons mentioned), I'll either use a macro that creates a var, or
use eval perhaps in conjunction with a memoize. I used this a lot in my
work with JavaFx. Do some reflection, generate some code, eval the code and
return a function, memoize that process so we can get the generated
function via name. So the interface looks like this:
((get-setter button :text) "hey")
Get-setter does a ton of reflection, but calling the returned function
remains fast due to the combination of eval and memoization.
On Thu, May 11, 2017 at 2:55 AM, Dragan Djuric
wrote:
> What's wrong with (foo :able) => "Adelicious!" and (:able foo) =>
> "Adelicious!"?
>
>
> On Thursday, May 11, 2017 at 9:20:19 AM UTC+2, Alan Thompson wrote:
>>
>> A recent question on StackOverflow raised the question of the best
>> way to automatically generate functions. Suppose you want to automate the
>> creation of code like this:
>>
>>
>>
>> (def foo
>> {:able"Adelicious!"
>>:baker "Barbrallicious!"
>>:charlie "Charlizable"})
>> (def bar
>> {:able"Apple"
>>:baker "Berry"
>>:charlie "Kumquat"})
>>
>> (defn manual-my-foo [item] (get foo item))
>> (defn manual-my-bar [item] (get bar item))
>>
>> (manual-my-foo :able) => "Adelicious!"
>> (manual-my-bar :charlie) => "Kumquat"
>>
>>
>> You could write a macro to generate one of these at a time, but you
>> can't pass a macro to a higher-order function like `map`, so while this
>> would work:
>>
>>
>> (generate-fn :foo) ;=> creates `my-foo` w/o hand-writing it
>>
>>
>> this wouldn't work:
>>
>>
>> (map generate-fn [:foo :bar :baz])
>>
>> While one could write a 2nd macro to replace `map`, this is a symptom
>> of the "Turtles All the Way Down" problem. One workaround is to avoid
>> macros altogether and use only functions to generate the required
>> `my-foo`
>> and `my-bar` functions. The trick is to make use of the built-in Clojure
>> function `intern` both to save the newly generated functions into the
>> global environment and to retrieve the pre-existing maps `foo` and `bar`.
>> Full details are available Q&A-style at the StackOverflow post
>>
Re: def with function call - how often executed?
When clojure reads this, it immediately evaluates `(+ 1 2)` => 3 so your
code looks like:
(def x 3)
So subsequent references to `x` just get the pre-computed value of 3 and
don't know how it was derived.
Alan
On Thu, May 11, 2017 at 9:58 AM, Kevin Kleinfelter <
kleinfelter.gro...@gmail.com> wrote:
> If I write a def with a function call, such as:
> (def x (+ 1 2))
> and I use x a gazillion times in my code, does Clojure execute the
> function ("+" in this case) on each use?
>
> Clearly, with (+ 1 2) it doesn't really matter, but if it is an expensive
> function such as reading a file it is a big deal.
>
> Tnx
>
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@googlegroups.com
> Note that posts from new members are moderated - please be patient with
> your first post.
> To unsubscribe from this group, send email to
> clojure+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Contract Clojure Developer Position (Mandarin Fluency) in Santa Clara, CA
Distributed System/Clojure Senior/Staff Software Engineer (Contract to possible hire) The main requirement for this position is strong experience with Clojure and Java on Linux. Must be fluent in Mandarin for technical communication (written and verbal). May consider limited Clojure experience if we have no candidates with both Mandarin and Clojure. Huawei is a $60B telecom / enterprise IT networking solution provider that is ranked #1 globally and serves 45 out of the top 50 operators. Huawei is using various distributed systems to build its cloud solution. Test these systems’ reliability is import for the quality of our offering. We believe this is a great opportunity to become an expert in exciting new cloud infrastructure technology. RESPONSIBILITIES: This position will be a key member of a small team building cloud testing framework and libraries. He/she will participate in the core system design and development. Our target system will build a set of core libraries to test various cloud components. Testing is done using the Jepsen framework. JOB REQUIREMENTS: The ideal candidate will have the following: - 5+ years proven records on infrastructure level software development experience. - 3+ years Clojure development experience. - 3+ years Java development experience. - Comfortable working in open source communities - Linux platform programming experience is a big plus. - Linux container or Docker experience is a big plus. - Any experience with or knowledge of Jepsen is a big plus. -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en --- You received this message because you are subscribed to the Google Groups "Clojure" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojure+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
Reducers exception when calling into
Hi,
I've run into a bizarre issue with reducers that is consistently
reproducible, but only on one set of systems. On a separate system with the
same OS and java, the error is not reproducible. The exception messages
seem to indicate that I've tried to access a reducible like a seq before
doing something like `into', but that's not the case. In fact, the
exception is thrown at the very line where I'm trying to call into on the
reducible.
The exception happens in a reducers chain like this:
(->> content
(r/map :vals)
r/flatten
(r/filter (comp #{1 2 3} :page-number))
(into []) ;; <-- exception occurs at this line
count)
Stack trace:
https://gist.github.com/tkocmathla/2d4bc38c2ac2977b6c421fc92cd812ed
$ java -version
java version "1.8.0_92"
Java(TM) SE Runtime Environment (build 1.8.0_92-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.92-b14, mixed mode)
$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=14.04
DISTRIB_CODENAME=trusty
DISTRIB_DESCRIPTION="Ubuntu 14.04.5 LTS"
Thanks for any insight,
m.
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
Reducers exception when calling into
The symptoms sound like you are running into a case where there are multiple protocol branches that apply - this is a case where the behavior is undefined and can vary between JVM executions. Looks like it's going down the seq reduce path. I'm not at a computer to check more precisely what the other preferred option might be. I think there's actually an open ticket about a similar case. -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en --- You received this message because you are subscribed to the Google Groups "Clojure" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojure+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
Re: Incomplete With Destructuring Lists
There is also this sort of solution: (def xs (range 9)) (let [ [[a b c] mid3 [d e f]] (partition 3 xs) ] [a b c mid3 d e f]) => (0 1 2 (3 4 5) 6 7 8) -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en --- You received this message because you are subscribed to the Google Groups "Clojure" group. To unsubscribe from this group and stop receiving emails from it, send an email to clojure+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.
