exercism.io - leap-year

[Floyd Arguello]

Trying out the LFE exercisms, and I'm stuck on the first one!

Here's where I'm at:

(defmodule leap     (export (leap-year 1))) (defun leap-year (year)     (and (= (rem year 4) 0)         (or (/= (rem year 100) 0)             (= (rem year 400) 0)))) I feel like that should work, but I get this error during compile: ffdtm:leap $ rebar compile ==> lfe (compile) ==> lutil (compile) ==> color (compile) ==> ltest (compile) ==> leap (compile) src/leap.lfe:4: unbound function: #(= 2) src/leap.lfe:4: unbound function: #(= 2) Compiling src/leap.lfe failed: ERROR: compile failed while processing ~/exercism.io/lfe/leap: rebar_abort

What is the unbound function on line 4? Is (year) expected to be a function, and not an argument?

Best,
Floyd

[Floyd Arguello]

Changing = to == did the trick.

[Mason Staugler]

= is used in pattern matching.

https://github.com/rvirding/lfe/blob/develop/doc/user_guide.txt#L161

[Robert Virding]

Yes, there is no =/2 function, that is what the "unbound function: #(= 2)" error tells us. As you have found it is called ==/2.

Robert

[Robert Virding]

Yes, in pattern matching = is used to show aliases, basically that two patterns should match at the same time. It is most commonly used like (= (tuple a b c) t) where they match that the data is a tuple and you bind a, b and c to the elements and it binds t to the whole tuple.

Robert

On 30 July 2015 at 22:12, Mason Staugler <ma...@staugler.net> wrote:

= is used in pattern matching.

https://github.com/rvirding/lfe/blob/develop/doc/user_guide.txt#L161

--
You received this message because you are subscribed to the Google Groups "Lisp Flavoured Erlang" group.
To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-e...@googlegroups.com.
To post to this group, send email to lisp-flavo...@googlegroups.com.
Visit this group at http://groups.google.com/group/lisp-flavoured-erlang.
For more options, visit https://groups.google.com/d/optout.

[Floyd Arguello]

Thanks for the responses - really enjoying LFE and the community!

Floyd

On Thursday, July 30, 2015 at 3:21:39 PM UTC-5, Robert Virding wrote:

Yes, in pattern matching = is used to show aliases, basically that two patterns should match at the same time. It is most commonly used like (= (tuple a b c) t) where they match that the data is a tuple and you bind a, b and c to the elements and it binds t to the whole tuple.

Robert

On 30 July 2015 at 22:12, Mason Staugler <ma...@staugler.net> wrote:

= is used in pattern matching.

https://github.com/rvirding/lfe/blob/develop/doc/user_guide.txt#L161

--
You received this message because you are subscribed to the Google Groups "Lisp Flavoured Erlang" group.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-erlang+unsub...@googlegroups.com.

[H Durer]

I'm a newbie myself, so beware this might not be right...

On Tue, Aug 4, 2015 at 1:50 AM, Eric Bailey <ifsixw...@gmail.com> wrote:

As an exercise, I've started implementing the various map functions from the CL HyperSpec and ran into a bit of a roadblock their variadic nature.

I know certain functions like the arithmetic operators and ++ are (seem?) variadic, so I'm wondering how I can write my own.

Have you looked at the source code and checked how those functions are implemented?

I assume one possibility at least is to define various functions with the same name but differing arity.

 

[...]

 

Related question: Given a defined function, is there a way to get its arity?

As in:
    (defun f (x y) (+ x y))

    (... f) ; <= 2

erlang:fun_info/1 seems to be your friend here.  It returns a property list with various pieces of info about the function.  So if you only want the arity, use

proplists:get_value(arity, erlang:fun_info(...)).

 

[Eric]

Unfortunately the source doesn’t really speak to me..

Thanks for the fun info about fun_info!

--
You received this message because you are subscribed to the Google Groups "Lisp Flavoured Erlang" group.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-e...@googlegroups.com.

[Eric]

Looks like it can be done with macros:

(defmacro plus
  ((x) x)
  ((x y)
   `(+ ,x ,y))
  ((x y . zs)
   `(plus (plus ,x ,y) ,@zs)))

Is the “dot” syntax planned for deprecation? I vaguely remember hearing something about that..

On Aug 4, 2015, at 1:50 AM, H Durer <h.du...@gmail.com> wrote:

--
You received this message because you are subscribed to the Google Groups "Lisp Flavoured Erlang" group.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-e...@googlegroups.com.

[Duncan McGreggor]

Yes, the canonical example for n-arity support in LFE is the macro hack. Robert gave it as an example in his FOSDEM talk (and slides). There's a version of it up on Rosetta Code, too:

 * http://rosettacode.org/wiki/Averages/Arithmetic_mean#LFE

It's not the dot syntax per se which is being deprecated, rather unquoted forms in patterns. You will need to use '(...) or (list ...) instead of (...) -- same for any other constructor/quoted forms valid in patterns. Your macro would need to be updated to:

(defmacro plus

  (`(,x) x)

  (`(,x ,y) `(+ ,x ,y))

  (`(,x ,y . ,zs)

   `(plus (plus ,x ,y) ,@zs)))

Note that all three patterns will need to be updated, since you were also using unquoted lists.

In general, you will probably find that an iterative approach will be faster (though when speed doesn't matter, the recursive functions in LFE can be quite beautiful). For instance, here's a fold over a sequence that clocks in at about 3 seconds:

> (set `#(,time ,result) (timer:tc (lambda () (lists:foldl #'+/2 0 (lists:seq 1 1000000)))))

#(2745963 500000500000)

> (* 1.0e-6 time)

2.7459629999999997

And then, defining a recursive add that's easy to use with long lists of integers, we see it take more than 4 times longer:

(defun plus

  (('() acc) acc)

  ((`(,head . ,tail) acc) (plus tail (+ head acc))))

> (set `#(,time ,result) (timer:tc (lambda () (plus (lists:seq 1 1000000) 0))))

#(11469620 500000500000)

> (* 1.0e-6 time)

11.469619999999999

However, I would just use (lists:sum ...) in this particular case:

> (set `#(,time ,result) (timer:tc (lambda () (lists:sum (lists:seq 1 1000000)))))

#(60255 500000500000)

> (* 1.0e-6 time)

0.060254999999999996

d

[Eric Bailey]

I wish I could un-cross-post this. Sorry.

Thanks for the examples and the explanation. The quoting scheme makes perfect sense. I just couldn't think of it at the time.

I wholeheartedly agree that lists:sum is preferable. I was only trying to think of a trivial example to highlight my general question.

Thanks, Robert, for your explanation too. You seem to have gotten it on the right thread...

[Robert Virding]

Just to confirm what Duncan wrote. When you write a pattern you should write it in the same way as you would write to build the structure so you need to use cons, list or list*. So your macro would become:

(defmacro plus
  ((list x) x)
  ((list x y) `(+ ,x ,y))
  ((list* x y zs) `(plus (plus ,x ,y) ,@zs))
  ;((cons x (cons y zs)) `(plus (plus ,x ,y) ,@zs))          ;Without macros in the patterns
  )

Or to do as Duncan did and used the backquote macro in the patterns as well which expand to the same thing.

Robert

P.S. It is very strange, when viewing directly in google groups I see this message and the other comments to you original message in the exercism.io thread but in my mail I see them under variadic functions. Computers are strange.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-erlang+unsub...@googlegroups.com.
To post to this group, send email to lisp-flavoured-erlang@googlegroups.com.

Visit this group at http://groups.google.com/group/lisp-flavoured-erlang.
For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google Groups "Lisp Flavoured Erlang" group.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-erlang+unsub...@googlegroups.com.
To post to this group, send email to lisp-flavoured-erlang@googlegroups.com.

[Eric Bailey]

On Aug 4, 2015, at 7:27 PM, Robert Virding <rvir...@gmail.com> wrote:

Just to confirm what Duncan wrote. When you write a pattern you should write it in the same way as you would write to build the structure so you need to use cons, list or list*. So your macro would become:

(defmacro plus
  ((list x) x)
  ((list x y) `(+ ,x ,y))
  ((list* x y zs) `(plus (plus ,x ,y) ,@zs))
  ;((cons x (cons y zs)) `(plus (plus ,x ,y) ,@zs))          ;Without macros in the patterns
  )

Awesome! I didn't know about list*. Will definitely put that to good use at some point. For cases like these I prefer the back quoting, personally.

Or to do as Duncan did and used the backquote macro in the patterns as well which expand to the same thing.

Robert

P.S. It is very strange, when viewing directly in google groups I see this message and the other comments to you original message in the exercism.io thread but in my mail I see them under variadic functions. Computers are strange.

I made the mistake of replying to the exercism.io thread with my phone's mail client, deleting the context and naively assuming that a message to lisp-flavo...@googlegroups.com with a new subject would create a new thread in the group. I went back and deleted the reply and mirrored it in an actual new thread on my computer, but alas it was too late... Computers are strange, indeed.

To unsubscribe from this group and stop receiving emails from it, send an email to lisp-flavoured-e...@googlegroups.com.
To post to this group, send email to lisp-flavo...@googlegroups.com.