jsmonk / hegel Goto Github PK

function sum(...numbers: Array<number>) {
  return numbers.reduce((a, b) => a + b, 0); // Error here
}

sum();             // 👌!
sum(1);            // 👌!
sum(1, 2);         // 👌!
sum(1, 2, 42);     // 👌!
sum(1, 2, 42, 14); // 👌!
// ...

Type "number" is incompatible with type "0"

Playground

Example from Rest Argument

Hi, Artem! I was amazed by your talk on HolyJS and I want to help :)

It would be cool to create a list of simple minor improvements that one could implement to get acquainted with the project. You could file these improvements as issues here labeled with good first issue.

This would be helpful for people like me who want to help, but don't know where to start.

The second example in https://jsmonk.github.io/hegel/docs/magic-types#propertytypeobj-key reports an error for propertyOf function - Function should return something with type "$PropertyType<O, K>"

ex: helper([fn, fnArgs]) => fn(...fnArgs)

https://www.typescriptlang.org/play/?ssl=15&ssc=1&pln=15&pc=7#code/C4TwDgpgBAggdiAYnKBeKAKAdDghgJwHMBnALilwQG0BdASjQD4KEBuAKHYDMBXOAY2ABLAPYpcAEwkZc5ODwC2AIwj4ANFCVzFK-AwDe7KMaj4IwHvnFQA1JvYBfTtz6DRKABYQANpHwAeRCgIAA9gCDgJYlgEZEYMIxMqLg0cLDACXAViGnIqRA0ABUyFc1ViQMYadjpyACVzSzgAFXAISqhDE1NGqygubBwM-CziOkdnL19VDCpJCQ0ARg0AJnogA

ref: https://twitter.com/rage_monk/status/1210257035192877059

const numbers: Array<number> = [];

numbers.fill(500); // Error here

Property "fill" does not exist in "Array<number>"

Playground

➜  try-hegel node --version
v10.15.3
➜  try-hegel hegel
(node:8609) ExperimentalWarning: The fs.promises API is experimental
variants.flatMap is not a function

Project structure (does not seem to matter):

➜  try-hegel ls -Ral
.:
итого 20
drwxr-xr-x   3 ruslan ruslan 4096 лют 20 12:44 ./
drwxr-xr-x 108 ruslan ruslan 4096 лют 20 12:25 ../
-rw-r--r--   1 ruslan ruslan   69 лют 20 12:44 .flowconfig
-rw-r--r--   1 ruslan ruslan  129 лют 20 12:42 .hegelrc
drwxr-xr-x   2 ruslan ruslan 4096 лют 20 12:45 src/

./src:
итого 12
drwxr-xr-x 2 ruslan ruslan 4096 лют 20 12:45 ./
drwxr-xr-x 3 ruslan ruslan 4096 лют 20 12:44 ../
-rw-r--r-- 1 ruslan ruslan   82 лют 20 12:45 index.js

Is it possible to have code optimisations like in Prepack and Closure Compiler.

In the case of DOM manipulations and JS generated CSS without continuous animations and update, generate the final rendering.

Can we have a JS. Flow, TS to Hagel Converter

This can be also used to convert Hagel to Hagel.

Which file format will be better for settings description: JSON, YAML, TOML or other.

It will be so good if to variant will be added few arguments related to choice :)

Seems like weak polymorphism isn't working =( I tried to fix it by myself, but it was very hard, code base is complicated enough for me. I think that something wrong at generic-type.js in changeAll method. When hegel tries to change return type () => <_a> to () => 1 sourceTypes and targetTypes become empty arrays after sourceType.reduce and then this.subordinateType.changeAll don't change anything.

It would be great if you give me a hint to fix this, and I could take a look one more time, but more closely. But if it's hard to fix it would be better if you take this issue

https://jsmonk.github.io/hegel/try#GYVwdgxgLglg9mABAQwDYHdkE8DOAKADwEpEBvAKESsQCcBTKEGpUSWBRPEi632hpkgIBuStQC+5SeQgIcUFBmw4AciFSpEAXkWZceMOtQkA9CcQxIcGvWiIoWAA51teIA

Make installation guide for CLI and language-server in README.md

const tuple: [string, number] = ["", 0];

const another = [...tuple, true] // another is unknown

Playground

Expected

another: [string, number, boolean]
// or
another: [string, number, true]

type Key = "demo" | "another" | "foo" | "bar"

const Foo = {
    another: 1,
    bar: 2,
    foo: 3,
    demo: 4,
}

function get(key: Key) {
    return Foo[key] // Error here
}

Property "  'another'
| 'bar'
| 'demo'
| 'foo'" does not exist in "{
	another: number,
	bar: number,
	demo: number,
	foo: number
}"

Playground

Variable defined, but Hegel don't match it:

https://jsmonk.github.io/hegel/try#GYVwdgxgLglg9mABBATgUwIZTQUTFFATwB4AVAPgAoBKRAbwCgBIdKEFJUSWBRNfIpQAOGQgBs4GACYAuRKVqMmLNGw71EUQkLRyA5HoA0iEeMlTEAX2bXrDLtHhIAFhjBSxaMlQwQ5lDDlwAGswOAB3MFoAXnJ6UwlpOVJLY3QpEAg0FH9A+NFE2XlLGLiFegY7CAQAZyg+AEZEaOR0LFwBQhoGBld3T0pmNAbDZko6BPMS5rjJ6QZqIA

Current behavior :

const softUser: { email: string, password: string, ... } = { // Error here
  name: "[email protected]",
  password: "qwerty",
  status: "offline"
};

Type "{
	name: '[email protected]',
	password: 'qwerty',
	status: 'offline'
}" is incompatible with type "{ email: string, password: string, ... }"

Playground

Example from Strict and Soft object types

https://jsmonk.github.io/hegel/try#MYGwhgzhAECC0G8BQ1XQOYFMAu0BGAFAJSIprkBOOArhQHbQBMA3GagL5vQQ74EBuYENUwAubtgoBLOuiLjqdACaYAZjMxLEnTkmAB7OhFxhoAXmh1MAdzjFWAegfRsATwAOmbgAt91EFp4XnTUALZBFPjUuFIwMqqYFFRakNDE5gB8lmEReobG0FoWYAB0eEA

• getter property type is inferred as () => number instead of number
• if I try to define both getter and setter - there is an error Duplicated property definition!

Ideally, it should check that input type for setter and return type of getter are the same.

Hi!

Currently I'm using TypeScript as a primary language but it lacks a predictable, complete and sound type system so this project looks very promising and I'm looking forward to the first release.

The question I'd like to ask is whether you're going to support higher-kinded types?

This is a commonly requested feature in languages like TypeScript#1213 and Flow#30 and the only possible solution is lightweight higher-kinded polymorphism which is implemented in libraries like fp-ts. But the solution is far from perfect, leads to poor DX and messy code.

However fully implementing HKT in Hegel would open doors to adopting battle tested FP practices from languages like Haskell and Scala.

https://jsmonk.github.io/hegel/try#GYVwdgxgLglg9mABAQwDwBUB8AKAdPmKAUwFsBnALkQEEAnW5ATw0wEpEBvAKEUVqKghaSQqTIBuLgF8gA

it reports Rest argument type should be an array-like error

Steps to reproduce:

1. git clone https://github.com/JSMonk/hegel
2. cd hegel/packages/language-server
3. npm run compile

Output:

npm run compile                                                                                                                                                                                                                            master [8160a4c]
npm ERR! missing script: compile

Playground reference: https://jsmonk.github.io/hegel/try#MYewdgzgLgBAhgLhgIxCANgUzmGBeGAQQCdi4BPAOgEsISzyAKAbQBYBdASgG4AoIA

https://jsmonk.github.io/hegel/try#GYVwdgxgLglg9mABACwM4BsAqcBKBzAIwApkAaRVc9ASkQG8AoRRCBVKRMOAJwFsAJRAF4UiAPSIAzADYADE0TpEAWkRFUiANSLqDAL5A

No description, website, or topics provided.

It would be cool to do like this

https://jsmonk.github.io/hegel/try#C4TwDgpgBAKgThCAeGA+KBeKBvAUFAgYwAsBLAGwBMEA7AZwC4oBBOOAQxBQWTXQB8oNAK7lyuAL4BuXLkIB7esCjAeTeIiQiAtgCMIcdFmxQSFahHpMRYqNLmK6ys1Vp1MKngDoXF+lKA

If we declare two functions:

const id = x => x
const K = a => b => a

And then pass id as the argument to K

const second = K(id)

Type of the function second will be <_c, _a>(_c) => _a,
but it should be something like <_c>(_c) => <_b>(_b) => _b

https://jsmonk.github.io/hegel/try#MYewdgzgLgBAlgExgXhgDxQPnQKFJWAM2hRgEMsYAjSsvcEiMJVYqACkQEp6CYwArgFsAXDACMpNu3Fd2AcnHye+RlABOY+QCZ5pJghlydynEA

I'm not sure maybe it is should be in this way but in TypeScript no errors:

interface B {
    a: number
    b: bool
}

good interence:
cosnt fn = (a, b) => a + b;
const res = fn(1, 2) //type is number

bad inference:
const fn = (a) => a.a + a.b;
const res = fn({a: 1, b: 2}) // type is number | string | bigint, but it can be just a number

The type system must infer { id: undefined | number } in that case?

const create = (model) => {}
const update = (model: { id: number }) => {}

// infer ({ id: number }) => undefined
const save = (model) => {
  if (typeof model.id === 'undefined') {
    create(model)
  } else {
    update(model)
  }
}

How could we accomplish Hegel to work with JSX?

// Type of "prop" function is "<_a: Object, _b: $Keys<_a>>(_a, _b) => $PropertyType<_a, _b>"
function prop(a, b) {
    return a[b]; // Error here
}

Type "$PropertyType<_a, _b>" is incompatible with type "_c"

Playground

This is from an example at Arguments

Hey, cool project. Was wondering if you're planning on supporting comment syntax. I use that w/ flow.js to avoid a build step. Would be great if hegel had something similar

Currently, types are shown on hover only for variables/functions.
It would be great to be able to see type when you hover object property.

This is a sample hover hint in typescript - (property) A.b: string.

https://jsmonk.github.io/hegel/try#MYGwhgzhAEBCkEtgGEwmAV3AFwPYCdoBvAKGnOgDc0MBTALmgDsMBbAI1sIF5oAGANwkyFYLiYRs+DMDz4AFNRB1ovPgEpiIihWwALBBAB0Slb1O0hOgL7bomfPlpNsANRq156xiw5ctOjpO2Bj4TND6hiYeVhS2OmAAJonyuAAOXGBMiT5snPiapIG6BsYW0ADUvOmZ2bHFwaHhkRD10La2JKCQMADKwAjO2AgAZkio6FhgctC0AB7Yzokw8BDjaJg4BAH24pLSsgSKHqr8hXYQGBkKFuqx8dBrTF475C3RyrSnALLTekZPeTvW5tRphCKle4kTpiCTYaCJU5MWgAd2g-UGLlG60mWwUACZ1CIjEkUgBGInkAEIZ6U6BGBxOFzuT5eARAA

if a method returns this - it is inferred as the class where a method was defined, and this will break chaining if used with child class.
typescript has special type this that is polymorphic and solves this issues
it would be great if hegel would correctly infer this for such cases

I have installed @hegel/cli globally first and then locally in project. But when I type hegel command output is like this below:

$ hegel
Path "events" cannot be resolved

What can it be?
P.S.: I install CLI with npm. Node version is 13.12.0

As soon as tagged template is used hegel stops returning error information.

For example

// Error: Type "'1'" is incompatible with type "number"
1 + '1';

With tagged template

// no errors at all
1 + '1';
a``;

Type inference seems to work, so the problem should be at error checking.

If I run CLI against file with such code I see only TaggedTemplateExpression in output.

https://jsmonk.github.io/hegel/try#GYVwdgxgLglg9mABHA1gCgIYCcDmBnASkQG8AoASG3wDoNSBfU00SWBRYDGAGzzWIz0iZSgyA

Small example:

const a: { a: number} = { a: 1 };
const b: {a : number | string } = a; // CORRECT, not allowed


function foo(obj: { a : number | string }) {}
const f: ({ a: number}) => undefined = foo; // INCORRECT, allowed

As far as i know yarn workspaces make work with lerna much more convenient

Can have haveWebAssembly compilation also.

Всем привет, заинтересовался вашим анализатором после просмотра доклада, спасибо что решили поделиться.
Решил подождать некоторое время, но сейчас захотелось попробовать его в живую.
В каком сейчас состоянии анализатор, можно ли его использовать уже в дикой среде?
Есть краткое руководство как его установить и запустить? (для тех кто не имел дело ранее с language-server).

Is it possible to take a step beyond type checking and add program verification and proofs like that is found in WhyML, Dafny and Ada SPARK 2014?

Following is a WhyML example:

module MaxAndSum

  use import int.Int
  use import ref.Ref
  use import array.Array

  let max_sum (a: array int) (n: int)
    requires { 0 <= n = length a }
    requires { forall i:int. 0 <= i < n -> a[i] >= 0 }
    returns  { sum, max -> sum <= n * max }
  = let sum = ref 0 in
    let max = ref 0 in
    for i = 0 to n - 1 do
      invariant { !sum <= i * !max }
      if !max < a[i] then max := a[i];
      sum := !sum + a[i]
    done;
    (!sum, !max)

end

The key is we can have specifications like:

requires { 0 <= n = length a }
requires { forall i:int. 0 <= i < n -> a[i] >= 0 }
returns  { sum, max -> sum <= n * max }

and

invariant { !sum <= i * !max }

Maybe you can move to hegel.js.org using https://js.org/

Also maybe this project can be moved to own GitHub organisation so it becomes more than and individual project.

This example doesn't work:
https://jsmonk.github.io/hegel/try#MYewdgzgLgBAhjAvDA3gWAFA2-AXDARgBpMcYAjfAJhKx2HwBZayATfAcjglY8wF9MmUJFgBrAKYBPCEhgB5cgCsJwKADpJMgBRwAlOoC2cAA7atSAHypS9cNBgA3OABsArhLlwA2loC6ANwCephAA

This code doesn't compile(ts example):

type UnionArray = Array<number> | Array<string>;

const mapArray = (arr: UnionArray): Array<string> => {
    return arr.map(element => {
        if (typeof element === 'string') { 
            return element + 'a';
        }

        return element.toString() + 'a';
    })
}

There is error in map method:

This expression is not callable.
  Each member of the union type '(<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])' has signatures, but none of those signatures are compatible with each other.