in typescript 4.0 Array.every (Seq.allMatch) is a type guard:
https://twitter.com/WrocTypeScript/status/1280505107982045198

we already do that for Seq.partition, let's do this also for Seq.allMatch.

Hello,

First, thanks for the work you've done. It's a great lib with many good implementations 👍( message from a VAVR fan !)

But, I would like to know if you plan to integrate some concept like the Try which is very useful for some pattern of code in Javascript. (like this one)

In our case, we want to avoid some kind of code, the most common is the following :

function extract(foo) {
  if (foo && foo.bar && foo.bar.another && foo.bar.another.and && foo.bar.another.and.again) {
    return foo.bar.another.and.again;
  }
  return null;

By doing this kind of thing:

function extract(foo) {
  return Try.of(() => foo.bar.another.and.again).getOrElse(null);

Or even better, simply return the monad and let the caller decide if null is a good candidate (which is not often the case)

So, do you plan to integrate this kind of element? Are you open to PR about this evolution?

/cc @Neonox31 @Yann29

In other words, get item given a function which calculates index given current vector length. This adds some sugar for my particular task: getting random item which is now like

const items = vector.map(...)....;
if (items.isEmpty()) {
    return undefined;
}
return items.get(getRandom(0, items.length)).getOrThrow();

It'll be also useful for getting median and other quantiles.

Perhaps it worth allowing selecting multiple items like Numpy-style, so signature will be like

Vector.select(fn: (length: number) => Vector<number>): Vector<T>

Or create both versions using overload. What are your thoughts?

As

is there a reason that undefined isn't handled here? Or would you take a PR that changes this?

Hi there :)

Is there any chance to get a real, serious constant binding, that does what it says?

So deep freeze combined with casual const.

Thanks a lot

Edit: Seems like readonly does the job.

Hi,
i'm trying to run some futures after each other, so i thought i could use the traverse function with maxConcurrent property set to one.

In my example, it doesn't work as i expected. The returned result shows me, that all futures are triggered at the same time.

const identity = x => x;

const createFuture = (message, timeout, ok) => 
    Future.ofPromiseCtor((resolve, reject) => {
        console.log("before:", message);

        setTimeout(() => { 
            console.log("after:", message); 
            return ok ? resolve("resolved") : reject("rejected")
        }, timeout);
    });

const futures = [
    createFuture("aaa", 1000, true),
    createFuture("bbb", 500, true),
];

Future.traverse(futures, identity, { maxConcurrent: 1 });

The log:

before: aaa
before: bbb
after: bbb
after: aaa

1)Right now there are

sortOn(getKey: ((v:T)=>number)|((v:T)=>string))
minOn(getNumber: (v:T)=>number)

Maybe It should be something like

type NativeOrderable = number | string | boolean
minOn(getKey: (v:T)=> NativeOrderable)
sortOn(getKey: (v:T) => NativeOrderable)

2. There is a common scenario when you want to sort something by two properties

type Foo = {a: number, b: number, c: number}

It's possible to use sortBy

fooList.sortBy((x,y) => arrayCompare([x.a, x.b], [y.a, y.b]))

But I think something like this could be better

sortWith<U>(map: T => U, compare: (v1:U,v2:U)=>Ordering)
fooList.sortWith(x => [x.a, x.b], arrayCompare)

or maybe even

sortOn(getKey: (v:T) => NativeOrderable | U, compare?: (v1:U,v2:U)=>Ordering)

The following hashCodes should not be equal, but they are:

expect(HashMap.of(["a", 1], ["b", 0]).hashCode()).not.toBe(HashMap.of(["a", 0], ["b", 1]).hashCode());

The reason for this is that the HashMap hash code is calculated for the pairs in isolation, combining the hash codes of the kv-pairs and summing them up.

Calculating the pairs in isolation is correct because I think the order is not guaranteed in a HashMap (otherwise you could just send the whole list entries to fieldsToHashCode instead).

Adding up the hash code of the key and the value is not, however, because that produces the false match as demonstrated above, as adding doesn't guarantee the uniqueness of the pairs of keys and values.

Something like this should fix it in the HashMap implementation:

HashMap.prototype.hashCode = function () {
  return this.hamt.fold(function (acc, value, key) {
    return acc + 37 * (Comparison_1.getHashCode(key) * Comparison_1.getHashCode(value));
  }, 0);
};

(Thank you for creating prelude-ts, by the way, our team has gotten a lot of value out of this library and I absolutely love it).

Tuple2.of(0, "").equals(Tuple2.of(0, "")) yields false

I'm on version 1.0.2

Hello,
after replacing another fp library with this one, i was missing the error type of a future.
Are there any reasons, why you don't allow to use a future like Future<L, R>?

Would it be possible to implement sequenceAcc for Option? Like you have for Either?

Could be used for validation - let's say you have a bunch of functions that - given some input - perform a validation and return Option<TValidationError> .

You want to apply all of those validation functions and get out an Option<TValidationError[]>. If none of the validation functions produce an error then the outcome would be none.

Something like this:

const optionSequenceAcc = <T>(values: Option<T>[]): Option<T[]> => {
  return values.reduce((accum: Option<T[]>, value: Option<T>) => {
    return value.match({
      None: () => accum,
      Some: (error) => Option.some<T[]>([...accum.getOrElse([]), error])
    })
  }, Option.none())
}

Hey, i was using option.match like this today:

const content = results.match({
  None: () => <Loader />,
  Some: movies => movies.map(movie => <MoviesListItem key={movie.id} {...movie} />)
})

However, the problem is that the None function returns an JSX.Element, which forces the Some function to then also return a JSX.Element, while i actually want it to return an array

So what i propose is to change the types at https://github.com/emmanueltouzery/prelude-ts/blob/master/src/Option.ts#L594 to have two generics, one for each function accepted

I made a typescript playground of it:
https://www.typescriptlang.org/play/index.html#src=type%20Option%3CT%3E%20%3D%20None%3CT%3E%20%7C%20Some%3CT%3E%3B%0D%0A%0D%0Aclass%20None%3CT%3E%20%7B%0D%0A%20%20%20%20constructor()%20%7B%20%7D%0D%0A%0D%0A%20%20%20%20match%3CU%2C%20V%3E(cases%3A%20%7BSome%3A%20(v%3A%20T)%3D%3E%20U%2C%20None%3A%20()%20%3D%3E%20V%7D)%3A%20U%20%7C%20V%20%7B%0D%0A%20%20%20%20%20%20%20%20return%20cases.None()%0D%0A%20%20%20%20%7D%0D%0A%7D%0D%0A%0D%0Aclass%20Some%3CT%3E%20%7B%0D%0A%20%20%20%20constructor(private%20value%3A%20T)%20%7B%20%7D%0D%0A%0D%0A%20%20%20%20match%3CU%2C%20V%3E(cases%3A%20%7BSome%3A%20(v%3A%20T)%3D%3E%20U%2C%20None%3A%20()%20%3D%3E%20V%7D)%3A%20U%20%7C%20V%20%7B%0D%0A%20%20%20%20%20%20%20%20return%20cases.Some(this.value)%3B%0D%0A%20%20%20%20%7D%0D%0A%7D%0D%0A%0D%0Aconst%20foo%20%3D%20new%20Some(10).match(%7B%0D%0A%20%20%20%20Some%3A%20()%20%3D%3E%20123%2C%0D%0A%20%20%20%20None%3A%20()%20%3D%3E%20%22123%22%0D%0A%7D)%20%2F%2F%3D%3E%20string%20%7C%20number%0D%0A%0D%0Aconst%20bar%20%3D%20new%20Some(10).match(%7B%0D%0A%20%20%20%20Some%3A%20()%20%3D%3E%20123%2C%0D%0A%20%20%20%20None%3A%20()%20%3D%3E%20123%0D%0A%7D)%20%2F%2F%3D%3E%20number%0D%0A%0D%0A

Like min, max, sum

I couldn't find an equivalent function in prelude-ts so please let me know if this exists and I am just missing it.

A common pattern on ADTs (algebraic data types) is ap (short for apply).

From the (Mostly Adequate Guide to Functional Programming)[https://mostly-adequate.gitbooks.io/mostly-adequate-guide/ch10.html#ships-in-bottles]:

ap is a function that can apply the function contents of one functor to the value contents of another.

Examples:
crocks
fp-ts
monet.js

In 0.7.11, if you call .map on an empty Vector, you get:

TypeError: Cannot read property '0' of undefined
  at Vector.map (node_modules/prelude.ts/src/Vector.ts:840:48)

This works fine in master though.

I have an example where I need to fetch some data asynchronously and then validate it, which I think lends itself to a type of Future

What do you think to the idea of a new type that consolidates Future with Either?

For example, the Left/Failure of my Future could be a network error.

Without a single type to represent this pattern, I have to map over the Future and then map over the Either, which is quite verbose and I don't really need that level of control.

Here's my proposal which I'm ready to implement:

interface Seq<T> {
    indexOf(predicate: (v: T) => boolean): Option<number>;
    lastIndexOf(predicate: (v: T) => boolean): Option<number>;
}

This can be useful for example in model-view updates:

highlight(id: string) {
    items
        .indexOf(item => item.id === id)
        .map(index => views.get(index))
        .ifSome(view => view.highlight());
}

This can be made with zipWithIndex and find but that'll be quite verbose, especially searching for last which would require Seq reversing. Yet this may produce some overhead copying lists.

Is it intentional that preludeTsContractViolationCb (

In my setup (with Mocha), when a test throws a string I don't get a stack trace. When it throws an exception, I do. Thus, running setContractViolationAction((message) => { throw new Error(message); }); before tests makes for much nicer errors.

But if you don't have objections, I think that it would be great to just change preludeTsContractViolationCb to do this by default.

In my opinion it's really odd package naming. It can be easily mistaken with file name. I would recommend using ts-prelude.

I am aware that there are other projects with odd naming like:
https://www.npmjs.com/package/lazy.js

Other examples that using my proposed naming:
https://www.npmjs.com/package/ts-promise
https://www.npmjs.com/package/ts-httpexceptions
https://www.npmjs.com/package/probot-ts

Let me know what do you think.

Hello!

First of all, I love your library. It offers exactly what others don't for me and the typings are just good.

I was wondering if there's a roadmap to a v1 release? (if you're even planning on doing one)

I'm already using this in production, but some team members have expressed concerns about the lack of a v1.0.0. I would love to contribute if possible!

Regards,

You mentioned this several times. Just wondering what's the problem with it? Perhaps I can help.

Hi,

Given the following

describe("HashMap", () => {
  it("Gives unique hash codes", () => {
    const map1 = HashMap.of(["48", 1], ["49", 2], ["50", 3], ["51", 4]);
    const map2 = HashMap.of(["49", 2], ["50", 3], ["51", 4]);
    const map3 = HashMap.of(["49345678", 2], ["50", 3], ["51", 4]);

    console.log(map1.hashCode(), map2.hashCode(), map3.hashCode());

    expect(map2.hashCode() !== map1.hashCode()).toBeTruthy();
    expect(map3.hashCode() !== map1.hashCode()).toBeTruthy();
    expect(map3.hashCode() !== map2.hashCode()).toBeTruthy();
  });
});

All hash maps are giving me the exact same hash code:

  ● HashMap › Gives unique hash codes

    expect(received).toBeTruthy()

    Received: false

      31 |     console.log(map1.hashCode(), map2.hashCode(), map3.hashCode());
      32 |
    > 33 |     expect(map2.hashCode() !== map1.hashCode()).toBeTruthy();
         |                                                 ^
      34 |     expect(map3.hashCode() !== map1.hashCode()).toBeTruthy();
      35 |     expect(map3.hashCode() !== map2.hashCode()).toBeTruthy();
      36 |   });

      at Object.<anonymous> (src/store/domain/types/DataClass.test.ts:33:49)

  console.log src/store/domain/types/DataClass.test.ts:31
    1696 1696 1696

Test Suites: 1 failed, 1 total

I'd expect some conflicts to be possible given the [comment] above the hashcode function, but since all 3 are returning 1696 even after arbitrary changes, this means we basically can't compare hash maps.

This is on the latest version of PreludeTS.

I'd love to help to fix this but the logic behind generating the hashcode is a bit above my head right now ):

When nuxt.renderJsonPayloads is enabled in Nuxt 3, it causes the error. Disabling this option in nuxt.config.ts allows the preview to work, but the error still appears in the console. I'm not sure if this is a problem with Nuxt itself, but since it's related to this specific dependency, I decided to create an issue here. Maybe someone else has encountered this issue and found a solution. 🤔

Here is a link to StackBlitz. The only modification I made to the original vitesse-nuxt3 repository is adding prelude-ts and utilizing Option in composables/user.ts for the savedName field. I also updated its usage in pages/hi/[id].vue.

The HashSet is nice to get equality checks. But when you are using it to display UI elements, vector/array is preferable since order of elements seems to change on each re-render of the application. But vector doesn't have the nice properties of HashSet.

Is there some way to get a LinkedHashSet like functionality (Something like: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-linked-hash-set/)?

In RxJS, there is a pluck operator for mapping items to nested properties, specified by strings.

I think this would nicely fit into Option, so we could write code like this:

interface Nested<T> {
  nested?: { value: T };
}

Option.some<Nested<string>>({ nested: { value: "x" } })
      .pluck("nested", "value")   // returns Option.some("x")

Option.some<Nested<string>>({ })
      .pluck("nested", "value")   // returns Option.none()

// Shouldn't compile since "invalid" is not a property of Nested
Option.some<Nested<string>>({ })
      .pluck("invalid")

Ideally, we should get compiler errors if pluck is passed a string that isn't a valid property of the wrapped type, like in the last example.
See the overloads of pluck in RxJS for inspiration how this can be done.

Firstly, thanks for the great library 🙂

It appears that the function returned from Either::liftApAcc closes over leftErrs from the outer scope.

That effectively means the function returned from Either::liftApAcc is stateful and can't be used more than once.

NB: I noticed while applying your suggestion from #61.

I believe this text should say "But if it was a Right..."

First thanks and congrats with 1.0.0 release!

Working on my last PR I had problem with sed: -i option is not standard and it didn't work on my system. I checked what sed is doing — in all places it just replaces by regex. What if I write simple TS script doing the same? I believe it will simplify further contributions.

We want a Future.liftXXX-like function as described there and in the rest of the conversation, and suggested by @qm3ster:
#8 (comment)

the only real hurdle left is the name for the function.

Hi,

stumbled upon a new equality issue

Option.of(Vector.of(12, 2674)).equals(Option.of(null))

yields true

i'm on "prelude-ts": "1.0.5"

Hi @emmanueltouzery.
I really like the idea of this API and like i am a FP fan.

I am using the VAVR in Java 8 projects.

I have a question, the API doesn't provide a "getOrElseGet" in the pattern Option, with a supplier in parameter (allows a lazy evaluation for the OR case).

Have you planned to add it in a futur release ?

Thanks for your help.

Hello @emmanueltouzery. Congratulations on a very nice looking library! 👍 I recently stumbled upon it and found it to be very interesting.

As you're aware I've created a library with an immutable list. I saw the really clever type you have for partition. I've just implemented it here. Thanks a lot for sharing the idea in your blog post!

I see that you've added List to your benchmarks 😄 I had already done so myself to see how the libraries compare. I'm going to work on improving performance in the cases where List is not as fast as your Vector.

I can see that you have "Non-empty vector?" on the "Wishlist/upcoming features". I have been thinking about adding such a feature to List. But, I'm now sure if it's worth it. What do you think? When does the feature help?

Option.ofNullable uses Javascript "truthiness" as its predicate, instead of comparing against null.

The result of this is that Option.ofNullable(0) returns None, instead of the expected value Some<0>

Vector.fold and similar have a signature like:

fold(zero: T, fn: (v1: T, v2: T): T): T

Many times you want to fold into a different type
This is common in FP langs. e.g. https://package.elm-lang.org/packages/elm/core/latest/List#foldl

I'm missing an alternative function?

Consider changing this to something like, where the accumulator can be something different.

fold(zero: U, fn: (v1: T, v2: U): U): U

Option.getOrThrow() currently takes a string as its argument. I think that it should take an Error instance, because throwing bare strings is generally considered poor Javascript coding practice.

Current method:

getOrThrow(message?: string): T & WithEquality {
    throw message || "getOrThrow called on none!";
}

Suggested:

getOrThrow(error?: Error): T & WithEquality {
    throw error || new Error("getOrThrow called on none!");
}

I've got some code like this

// We're populating a FinancialTransaction bit by bit

// Start in the "right" state with just the transactionId populated
const initial = Either.right<TransactionParseFailure, Partial<FinancialTransaction>>({ transactionId });

// Curry the raw-data in - populateAmount takes a partial financial transaction and returns either 
// - a TransactionParseFailure (left) or 
// - a partial financial transaction with the amount field populated (right)
const populateAmount = PopulateAmount(rawData);

// Curry the raw-data in - populateTransactionDate takes a partial financial transaction and returns either 
// - a TransactionParseFailure (left) or 
// - a partial financial transaction with the date field populated (right)
const populateTransactionDate = PopulateTransactionDate(rawData);

return initial
  .flatMap(populateAmount)
  .flatMap(populateTransactionDate)
  .map(PopulateOptionalFields);

However I'd like to change this so that we accumulate the errors - at the moment, it stops as soon as it ends in a left state. I think normally I'd do this with a Validation type, however prelude-ts is missing one currently.

I can't seem to get my head around how to achieve this with Either.sequenceAcc or Either.liftApAcc

as in vavr
https://www.javadoc.io/static/io.vavr/vavr/0.10.0/io/vavr/collection/Vector.html#rotateLeft-int-

I am trying your library:

import { Vector } from 'prelude.ts';

But I got this error:

src/index.ts:5:24 - error TS2691: An import path cannot end with a '.ts' extension. Consider importing 'prelude' instead.

So I tried only prelude as it suggests and that crashes with this:

src/index.ts:5:24 - error TS2307: Cannot find module 'prelude'.

When I was installing the package I thought the name is a bit weird, but I didn't expect it is not supported by TypeScript.

TS: 3.1.3
prelude.ts: 0.8.1

import { HashMap } from 'prelude.ts';
HashMap<string, string>.empty().findAny(() => true);

Results in:

TypeError: this.hamt.entries is not a function
    at EmptyHashMap.HashMap.findAny (node_modules/prelude.ts/src/HashMap.ts:381:53)
    at Object.<anonymous> (test.ts:2:33)

Hi, I recently switched to vite for building but get an error "util.inspect is not defined" from Value.ts when opening in the browser. I briefly tried looking why say webpack polyfills util.inspect but vite does not. But then on the node documentation for util.inspect https://nodejs.org/api/util.html#util_util_inspect_custom it mentions that the symbol is also available at Symbol.for("nodejs.util.inspect.custom").

So rather than try and deal with polyfills, I just switched prelude-ts to use Symbol.for which in the browser will just create a new symbol while on node will find the correct symbol.

I'll admit I just made the change directly in node_modules just to get by since I am just evaluating switching to vite. I can create a real pull request if you like.

continuing the discussion from #8

@qm3ster => all good points, food for thought. Note that prelude.ts has a Stream collection type and yes it works as you described. I would consider renaming the on* methods and have them possibly returning void instead of returning the Future, but I'm not sure for the name right now (maybe onFailed=>ifFail, onSucceeded=>ifSuccess, onCompleted=>match or matchValue), or even if that's really the good path forward.
That's also connected to some changes I'm working on in these methods regarding error handling.

And besides that I think yes probably map & flatMap should be lazy, and we can also add an explicit. .trigger() (with in apidoc that you don't need it if you do await, or if you do X or Y and so on). The trigger would likely return void.

Hi, first I'd like to say your great lib is a real relief after all these unnatural for TS X.compose(..., ...)(data). Operating collections in Scala-style is a real pleasure. That's huge and valuable work, thanks.

Now the question is — do you welcome suggestions and code? If you do, I'd create issues whenever I have an idea (I have some), so they can be discussed; then proceed with PR if an idea is accepted. What are your thoughts?

This code:

import { Vector } from 'prelude.ts';

let v = Vector.ofIterable(Array(15).fill(1));

for (let i = 0; i < 100; i += 1) {
  console.log(i);
  v = v.appendAll(Array(1000).fill(1));
}

Will fail after 86 iterations with:

TypeError: Cannot read property '0' of undefined
    at Vector.getLastNode (node_modules/prelude.ts/src/Vector.ts:279:31)
    at Vector.appendAllArrays (node_modules/prelude.ts/src/Vector.ts:457:34)
    at Vector.appendAll (node_modules/prelude.ts/src/Vector.ts:419:25)

There maybe a way already to allow this. I would like to be able to use interfaces for the elements. At the moment I believe that would mean having equals and hashCode on the interface which would then mean creating an instance of the interface would require setting those each time.

If the collection implementations could take an EqualityComparer which has those 2 methods then I believe I could use interfaces.

Another advantage is that I could then have different Equality for the same interface. My main Interface is:

interface Fact { subject: string, property: string , value: string }

Depending on the circumstance any of the properties could be the key or any combination also.

Thanks.

As per title, I think the "Set, Map and equality" paragraph in the readme is redundant. The same thing can be found in the Wiki.

Also, in the Wiki it's a bit uncomfortable having to click on the "Prelude−ts user guide" link to read something. Wouldn't it be better to make it the Wiki home?

Edit: for the Predicate Wiki paragraph, maybe you can add this real-world example:
Before:

let filtered = jobs.filter(job => filteredDomains.includes(job.domain))

if (selectedTagsIds.length) {
  filtered = filtered.filter(job => job.tags.some(tag => selectedTagsIds.includes(tag)))
}

const jobNameFilter = filteredJobName.trim()

if (jobNameFilter) {
  filtered =
      filtered.filter(job =>
          job.name.toLowerCase().includes(jobNameFilter.toLowerCase()))
}

return filtered

After:

const jobNameFilter = filteredJobName.trim()
const predicates = Predicate.allOf(...[
  (j: Job) => filteredDomains.contains(j.domain),
  ...selectedTagsIds.length() ? [(j: Job) => j.tags.some(t => selectedTagsIds.contains(t))] : [],
  ...jobNameFilter ? [(j: Job) => j.name.toLowerCase().includes(jobNameFilter.toLowerCase())] : []
])

return jobs.filter(predicates)