6 ms·
Is this really a philosophical difference? Granted, I've only used Clojure as far as Lisps go, but composability seems to be something that's emphasized. Rathe
by fnordsensei 11y ago
Is this really a philosophical difference? Granted, I've only used Clojure as far as Lisps go, but composability seems to be something that's emphasized.
Rather than
(remove-if-not #'p xs :count 5 :start 3)
It seems to me like most Clojure users would do something like
(->> xs (drop 3) (filter p) (take 5))
which is much closer to
take 5 . filter p . drop 3
- icholy 11y agoUnlike CL/EL, Clojure is lazy by default. So it's closer to Haskell in that regard.
- catnaroek 11y agoMinor nitpick. Technically, this: #(->> % (drop 3) (filter p) (take 5)) Is equivalent to: take 5 . filter p . drop 3
- fnordsensei 11y agoIs take 5 . filter p . drop 3 An anonymous function call in Haskell? I don't know the language (although it's on my to-learn sequence).
- catnaroek 11y agoIt's an anonymous function, which it not being called.
- deleted 11y ago[deleted]
- catnaroek 11y agoYou probably meant to reply to mietek.
- mietek 11y agoYes, written in pointless style. You could make it less pointless by replacing the (.)s with a point. \xs -> take 5 (filter p (drop 3 xs)) https://wiki.haskell.org/Pointfree https://wiki.haskell.org/Pointfree
- marcosdumay 11y agoYes. It's three anonymous ("take 5", "filter p" and "drop 3") functions composed by the "." operator, creating another anonymous function. One of the types, for example: take :: Int -> [a] -> [a] What means a function that takes an Int argument and returns another function, that takes a list and returns a list of the same type.
- pja 11y agoghci will (usually) tell you: phil@arod:~$ ghci GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> :t take 5 . filter (\ _ -> True) . drop 3 take 5 . filter (\ _ -> True) . drop 3 :: [a] -> [a] So it’s a function from List of a to List of a
- deleted 11y ago[deleted]
- takle 11y agoOne could also change the Haskell. Data.Function (&); Control.Arrow (>>>) -- the pipe operator seems to be all the rage these days (|>) = (&) -- forward application + forward composition xs |> (drop 3 >>> filter p >>> take 5) Only function application xs |> drop 3 |> filter p |> take 5
- catnaroek 11y agoI never understood the appeal of the pipe operator. It's a kludge to work around the need to eta-expand chained function compositions, which in turn is a kludge to work around the value restriction, which in turn is a kludge to prevent the combination of polymorphism and storage effects from breaking type soundness. Haskell doesn't need any of this.
- takle 11y agoI agree with you. I'm going to write a post about function application and composition (right-to-left / left-to-right) so other communities can stop discussing non-essential matters. I do like the fact that the `pipe operator` is often mentioned along the bash '|' which is used in a pointfree style. Well it might make sense sometimes, so its good to know one's options :) p x y z = f (g x y) z p = ((.) f) . g
- galfarragem 11y agoMy first contact with programming (besides BASIC) was (auto)lisp. It was kind of a first love: every language I tried after Lisp was a disappointment. Then I found Haskell..
- galfarragem 11y agoA bit off topic: interesting link with project euler solutions written in haskell and clojure (and sometimes other languages). With execution time log. http://zach.se/project-euler-solutions/ http://zach.se/project-euler-solutions/
- agumonkey 11y agoFunny how when I think about Lisp I think about that kind of code, while other people see elisp imperative, autolisp and common-lisp full-featured system.
- adrusi 11y agoClojure, and to a slightly lesser extent scheme, are much more Haskell-like than common lisp or emacs lisp. Clojure of course has pattern matching and lazy sequences, so naturally for collections it is very compatible with Haskell's philosophy.
- ogroide 11y agoIs not the same, in lisp :count 5 means that you remove at most 5 elements, so that the result can be a list of 100 elements, while take 5 will always produce a sequence with at most 5 elements. (remove-if-not #'evenp (loop for i below 10 collect i) :count 3 :start 0) result is (0 2 4 6 7 8 9), there are three elements deleted.
- fnordsensei 11y agoWell, that is different, but I suppose the Haskell example suffers from the same difference then.