returns array, should be single value
tests are invalid as well
from gkz/LiveScript#67

Similar to http://lodash.com/docs#range

Hey,

I thought about changing sortBy. Imho, its current name isn't describind what it does. I think it should be called sortWith
And maybe a sortBy function :

sort-by = (prop, list) --> list.sort (a, b) -> 
  | a[prop] < b[prop] => -1
  | a[prop] > b[prop] => 1
  | otherwise         => 0

Pretty useful dual to fold. Also, in prelude.hs, as you know.

Need for bower and component integration.
Now, when I include prelude-ls to my bower.json (brunch.io based project), result app.js contains all unwrapped scripts from prelude-ls folder, include tests.

would it be useful to have that fn since js doesn't have great immutability support out-of-box?

some-complex-dict |> clone |> transform (x y z)

lodash impl.

http://underscorejs.org/#extend
jQuery has it too.

I commonly use it to overwrite default options object with whatever options object the caller passed in.

markdotto/github-buttons#25
markdotto/github-buttons@f096916

When compiling LiveScript with -d flag, it inserts a code snippet on the top to install prelude to global namespace. But the install method call fails.

LiveScript version is 1.1.1
prelude version 1.0.3

/sandbox/lib/index.js:2
  require('prelude-ls').installPrelude(global);
                        ^
TypeError: Object #<Object> has no method 'installPrelude'

Now that Harmony generators have landed in V8 (behind a flag, but still), we should add syntax for them. I suggest -*> as a parallel to function*.

How to bind this to a function, like concat-map for example? I tried the following with no luck:

(concat-map.bind @) f, @x
concat-map.call @, f, @x
(concat-map.call @, f) @x

Any ideas? I see that curry$ helper keeps track of the context, but how to change it?

In the doc you the example for last and initial is wrong.

Also I can't find last in the left pane.

It seems when I try to use overloaded functions like map I can only have the List or the Obj version on the map symbol. Is there any way to make this work like underscore, where both use the same symbol?

Compiler warns about +++.

Hello,

It's not a big issue since it doesn't prevent from doing anything, it's just that I've been surprised to notice that the following reference:

prelude.repeat

was undefined, forcing me to use:

prelude.Str.repeat

while, there isn't any name collision with other sub-module (cf doc, section Function reference).

Maybe for a future repeat in List?

PS: of course the previous snippets consider the following code has been executed before:

require! prelude: 'prelude-ls'

The doc example is wrong.

concatMap (+ 2), [[1 2] [3]]

returns

21,223

I think it's much better if we could find a way to generate documentation from tests.

That is the only way to keep everything in sync with no manual checks.

Adding code means adding tests/docs automatically.

Mocha is doing this pretty ok.

But you see the assertions.

https://github.com/cdnjs/cdnjs

do this once the new version is released

Would you be prepared to add a cons to the prelude? maybe

cons = (x,xs) -> [x] ++ xs

It doesn't seem that http://gkz.github.com/prelude-ls/#f-zip is a curried function.

Does this mean I cannot do:

array2 |> map zip array1 |> ...

Tried it without success.

Think it has to do that it is not a curried function.

If so, could it be done that zip takes at least 2 arrays (seems pointless to take one).

If only one is supplied, then it returns a partial function.

What do you think?

the minified version does not attach prelude to anything, and the unminified version just errors out. Also the website says to use npm install prelude-ls and then point to the browser version, but the browser version is not include in the npm package.

I love to have sequence predefined in prelude.ls:

sequence = (fs, v) --> [f v for f in fs]

I noticed a minor issue in the definition of fix - it takes an additional, unnecessary argument. The definition should read:

fix = (f) ->
  ( (g) -> -> f(g g) ...&) do
    (g) -> -> f(g g) ...&

// javascript
var q = [ 'a', 'abc', 'z', 'chaoeu' ];
uniqueBy(function(it){return it.length;}, q); // works
uniqueBy(function(it){return it.length;})(q); // TypeError: Cannot read property 'length' of undefine

var x = curry(uniqueBy);
x(function(it){return it.length;})(q); // works again

livescript

here's a simple workaround until it's fixed:

prelude-has-a-bug-in-the-uniqueby-function = curry unique-by

Hi

I recently needed to use the findIndex method described here :
http://hackage.haskell.org/package/base-4.6.0.1/docs/Data-List.html#g:16

I've quickly implemented it for my project but I wonder if it would make sense to include it in the default prelude-ls package ?

After running a file with livescript -d program.ls :

Failed at: program.ls
TypeError: Object #<Object> has no method 'installPrelude'
    at Object.<anonymous> (/home/cdc/code/program.ls:2:25)
1| if (typeof window == 'undefined' || window === null) {
2+   require('prelude-ls').installPrelude(global);
3| } else {
4|   prelude.installPrelude(window);
5| }
6| 'use strict';

~/node_modules/prelude-ls $ grep -riP "installPrelude" .
~/node_modules/prelude-ls $

So basically, the installPrelude function was removed in the prelude refactor, but the corresponding code hasn't been updated in livescript -d yet.

The doc says you should run

prelude.importPrelude(window)

in the browser to install it in global namespace.

It should be

prelude.installPrelude(window)

I just hit this and thought I was probably just too tired to code or something, but after narrowing down the problem I figured that there is a serious bug with take-while and drop-while:

livescript> take-while (== 42), [42]
[]
livescript> take-while (== 42), [42 42 42]
[ 42, 42 ]
livescript> drop-while (== 42), [42]
[ 42 ]
livescript> drop-while (== 42), [42 42 42]
[ 42 ]

Looking at the generated javascript code for take-while:

for (i$ = 0; i$ < len; ++i$) {
  i = i$;
  if (!p(xs[i])) {
    break;
  }
}
return xs.slice(0, i);

len is actually never assigned to i because the condition i$ < len would fail first, and xs.slice 0 takes i which is len - 1 if all tests are successful and would take one less element. The same problem exists for drop-while as well.

My proposal is something like this:

find-index = (p, xs) -->
    for i til xs.length
        return i if p xs[i]
    return xs.length

take-while = (p, xs) --> xs.slice 0, (find-index ((not) << p), xs)

drop-while = (p, xs) --> xs.slice (find-index ((not) << p), xs)

should be nice have support for function sort. like sort, sortBy and multiSortBy (that can sort on more keys)

LiveScript 1.2.0, prelude 1.1.1 (from npm)

empty {} returns true
empty { a: 1 } returns true (when it should return false)

In Haskell, there is a very useful combinator in Data.Function called on which is defined as:

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
f `on` g = \x y -> g x `f` g y

translated to Livescript:

on = (f, g, x, y) --> (g x) `f` (g y)
same-length = (==) `on` (.length)
same-length [1 to 5] [6 to 10] # true

Unfortunately, this won't work because on is already a keyword in Livescript (an alias of true), so we have to find a new name for that.

After creating an extension system ala underscore.js #45

Add various functions which cover functionality that is present in LiveScript, but not in JS/CS

Could you please also be making a non-minified version for browser? And including it to npm package so it can be read by node.js?

With brunch, minifying is only done in production envs (automatically), and in dev env it's useful to use non-minified files because of cool traces etc.

Would like to have the K combinator, or the function known as const in Haskell, in prelude.ls. Since const is already a keyword in LiveScript, I would suggest simply using k or something else for its name.

The implementation should be straight forward in LiveScript: k = (x, y) --> x or k = (x) -> (y) -> x for better performance.

Add categorize function like:

categorize =  (f, xs) --> 
  f = objToFunc f if typeof! f isnt \Function
  type = typeof! xs
  result = {}
  if type is \Object
    for key, x of xs
      category = f x
      result[category] ?= {}
      result[category][key] = x
  else
    for v in xs
      k = f v 
      result.(k) ?= []
      result.(k).push v
  result

I think that should be self explanatory and the the usefulness also pretty obvious. You like?

Use define() as consistent with the AMD standard.

If you run replicate 3, 3 you get [3, 3, 3].
If you run replicate 3, "foo" you get "foofoofoo"

Is this a bug or is it meant to be like this? It is very inconsistent, i think it should return ["foo", "foo", "foo"] instead.

create a deep copy of objects/arrays

gkz/LiveScript#224

The type of concat-map is documented as (a → b) → [[a]] → [b] but it should be (a → [b]) → [a] → [b]

http://preludels.com/#concat-map

Wrong:

difference [1 2 3] [1]              #=> [1, 2]

Correct:

difference [1 2 3] [1]              #=> [2, 3]

So that extensions to prelude can be written and easily integrated. Something like in underscore.js

Am I crazy, or are the operations reversed?

const get-args = (fn)->
   const s = fn.to-string!.replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/g, "")
   s.slice(s.index-of(\() + 1, s.index-of(\))).match(/([^\s,]+)/g) ? []


#examples

get-args ($scope, $route-params) -> #["$scope","$routeParams"]

get-args -> #[]

Who use angular directives should like it

Because then

const body = (fn)->
   get-args(fn) ++ [fn]

Hi!!..I know than prelude is based in the haskell module..but would you add the intersect fuction?...in f# I use sets..but javascript only has arrays...so...I think it would be an important add....

thanks!!!

Both underscore.js and native javascript array forEach/map/filter/etc provide index values as the the second argument to the function. For example:

[1,3,5].map(function(d,i) { return [d,i] })
// [[1,0],[3,1],[5,2]]

It would be convenient if the prelude functions behaved the same way

I use changelog.md in all my non-webapp projects. Pretty useful stuff.

Example: https://github.com/paulmillr/es6-shim/blob/master/CHANGELOG.md. I propose to add it to prelude too.

prelude-browser-min.js not prelude-min.js in installation section

Installing prelude into the global namespace with prelude.installPrelude(window) fails in IE<=8.

This seems to be because IE versions <=8 don't allow overwriting properties on the window object. Because prelude includes a function called 'length', and error is throw when attempting to overwrite window.length. Incidentally, other JS environments' window have a .length too, but they don't mind if you overwrite it.

I got around this for my project by adding a function to prelude called 'safeInstall' which simply renames the 'length' function to 'len' while copying, if it detects that the destination object is window.

There are valid reasons to ignore this bug, for example, changing the function name breaks the isomorphism to the Haskell prelude library, diverges the API for other maintainers of the code, and you may or may not care about supporting IE8. These things don't happen to be a problem for me personally, but might prevent you incorporating a fix into the master. I just thought I'd bring this to your attention - maybe it's worth noting in the docs at least.

Thanks
L

foldr1 (-), [1 2 3 4 9] #=> 7

Wouldn't that be -1?

Also these two are wrong:

foldr (-), 9, [1 2 3 4]       #=> 7
foldr (+), 'e', <[ a b c d ]> #=> 'abcde'

http://lodash.com/docs#intersection
http://lodash.com/docs#difference
http://lodash.com/docs#union