Question: unusable sample code

[pbelbin]

I'm doing some usage of your package, with TypeScript.

I see in your documentation an example that shows:

let pool: Pool<ThreadType>

Well, perhaps I'm missing something, but ThreadType is not exposed it seems (or, it's hidden somewhere)? Or, is this supposed to be a placeholder for something else?

I want to declare (with type information) a variable like what you've shown, but, like I said, it seems ThreadType is not exposed.

What's supposed to be used here?

Another issue is that when I do something like this:

const x = Pool(spawnWorker, 1);

VSCode is able to show me that x has been attributed a type of:

const x: WorkerPool<FunctionThread<[filename: string], string | Result>>

But, again, it seems I am not able to import all of these discreet types :(

What I really want to be able to do is say that I have an object having a variable/as yet unknown number of (referenced by string key) Pool(()=> spawn<WorkerFunction>(new Worker('./worker')), 1) results.

eg:

	const spawnWorker = () => spawn<WorkerFunction>(new Worker('./worker'));
	
	const pools: {
		[index: string]: WorkerPool<FunctionThread<[filename: string], string | Result>>;
	} = {};

so I can add to my pools like this:

     pools['thing1'] = Pool(spawnWorker, 1);

But, again, WorkerPool and Result do not appear to be exposed.

A little help please?

[andywer]

Sorry for the late response, @pbelbin, but I have been sick the last few days.

Regarding ThreadType…
Yeah, that's really not so clear, but that's just a placeholder for <use the type of the interface that your thread exposes here>. We should fix that bit of documentation.

Regarding WorkerPool…
The WorkerPool is the class that implements the Pool interface. That means you can just use Pool<T> instead of WorkerPool<T>:

threads.js/src/master/pool.ts

Line 114 in 4d6f550

class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {

It's much harder to tell where Result comes from without looking into the code. Might be some artifact of some generic utility type, but might just as well be one of your app's types that TypeScript infers there.